/programs/develop/libraries/newlib/string/strcasestr.c |
---|
0,0 → 1,147 |
/* |
FUNCTION |
<<strcasestr>>---case-insensitive character string search |
INDEX |
strcasestr |
ANSI_SYNOPSIS |
#include <string.h> |
char *strcasestr(const char *<[s]>, const char *<[find]>); |
TRAD_SYNOPSIS |
#include <string.h> |
int strcasecmp(<[s]>, <[find]>) |
char *<[s]>; |
char *<[find]>; |
DESCRIPTION |
<<strcasestr>> searchs the string <[s]> for |
the first occurrence of the sequence <[find]>. <<strcasestr>> |
is identical to <<strstr>> except the search is |
case-insensitive. |
RETURNS |
A pointer to the first case-insensitive occurrence of the sequence |
<[find]> or <<NULL>> if no match was found. |
PORTABILITY |
<<strcasestr>> is in the Berkeley Software Distribution. |
<<strcasestr>> requires no supporting OS subroutines. It uses |
tolower() from elsewhere in this library. |
QUICKREF |
strcasestr |
*/ |
/*- |
* Copyright (c) 1990, 1993 |
* The Regents of the University of California. All rights reserved. |
* |
* The quadratic code is derived from software contributed to Berkeley by |
* Chris Torek. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* 1. Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* 2. 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. |
* 4. Neither the name of the University nor the names of its contributors |
* may be used to endorse or promote products derived from this software |
* without specific prior written permission. |
* |
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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. |
*/ |
/* Linear algorithm Copyright (C) 2008 Eric Blake |
* Permission to use, copy, modify, and distribute the linear portion of |
* software is freely granted, provided that this notice is preserved. |
*/ |
#include <sys/cdefs.h> |
#include <ctype.h> |
#include <string.h> |
#if !defined(PREFER_SIZE_OVER_SPEED) && !defined(__OPTIMIZE_SIZE__) |
# define RETURN_TYPE char * |
# define AVAILABLE(h, h_l, j, n_l) \ |
(!memchr ((h) + (h_l), '\0', (j) + (n_l) - (h_l)) \ |
&& ((h_l) = (j) + (n_l))) |
# define CANON_ELEMENT(c) tolower (c) |
# define CMP_FUNC strncasecmp |
# include "str-two-way.h" |
#endif |
/* |
* Find the first occurrence of find in s, ignore case. |
*/ |
char * |
strcasestr(s, find) |
const char *s, *find; |
{ |
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__) |
/* Less code size, but quadratic performance in the worst case. */ |
char c, sc; |
size_t len; |
if ((c = *find++) != 0) { |
c = tolower((unsigned char)c); |
len = strlen(find); |
do { |
do { |
if ((sc = *s++) == 0) |
return (NULL); |
} while ((char)tolower((unsigned char)sc) != c); |
} while (strncasecmp(s, find, len) != 0); |
s--; |
} |
return ((char *)s); |
#else /* compilation for speed */ |
/* Larger code size, but guaranteed linear performance. */ |
const char *haystack = s; |
const char *needle = find; |
size_t needle_len; /* Length of NEEDLE. */ |
size_t haystack_len; /* Known minimum length of HAYSTACK. */ |
int ok = 1; /* True if NEEDLE is prefix of HAYSTACK. */ |
/* Determine length of NEEDLE, and in the process, make sure |
HAYSTACK is at least as long (no point processing all of a long |
NEEDLE if HAYSTACK is too short). */ |
while (*haystack && *needle) |
ok &= (tolower ((unsigned char) *haystack++) |
== tolower ((unsigned char) *needle++)); |
if (*needle) |
return NULL; |
if (ok) |
return (char *) s; |
needle_len = needle - find; |
haystack = s + 1; |
haystack_len = needle_len - 1; |
/* Perform the search. */ |
if (needle_len < LONG_NEEDLE_THRESHOLD) |
return two_way_short_needle ((const unsigned char *) haystack, |
haystack_len, |
(const unsigned char *) find, needle_len); |
return two_way_long_needle ((const unsigned char *) haystack, haystack_len, |
(const unsigned char *) find, needle_len); |
#endif /* compilation for speed */ |
} |
/programs/develop/libraries/newlib/string/strcat.c |
---|
0,0 → 1,104 |
/* |
FUNCTION |
<<strcat>>---concatenate strings |
INDEX |
strcat |
ANSI_SYNOPSIS |
#include <string.h> |
char *strcat(char *<[dst]>, const char *<[src]>); |
TRAD_SYNOPSIS |
#include <string.h> |
char *strcat(<[dst]>, <[src]>) |
char *<[dst]>; |
char *<[src]>; |
DESCRIPTION |
<<strcat>> appends a copy of the string pointed to by <[src]> |
(including the terminating null character) to the end of the |
string pointed to by <[dst]>. The initial character of |
<[src]> overwrites the null character at the end of <[dst]>. |
RETURNS |
This function returns the initial value of <[dst]> |
PORTABILITY |
<<strcat>> is ANSI C. |
<<strcat>> requires no supporting OS subroutines. |
QUICKREF |
strcat ansi pure |
*/ |
#include <string.h> |
#include <limits.h> |
/* Nonzero if X is aligned on a "long" boundary. */ |
#define ALIGNED(X) \ |
(((long)X & (sizeof (long) - 1)) == 0) |
#if LONG_MAX == 2147483647L |
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080) |
#else |
#if LONG_MAX == 9223372036854775807L |
/* Nonzero if X (a long int) contains a NULL byte. */ |
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080) |
#else |
#error long int is not a 32bit or 64bit type. |
#endif |
#endif |
#ifndef DETECTNULL |
#error long int is not a 32bit or 64bit byte |
#endif |
/*SUPPRESS 560*/ |
/*SUPPRESS 530*/ |
char * |
_DEFUN (strcat, (s1, s2), |
char *s1 _AND |
_CONST char *s2) |
{ |
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__) |
char *s = s1; |
while (*s1) |
s1++; |
while (*s1++ = *s2++) |
; |
return s; |
#else |
char *s = s1; |
/* Skip over the data in s1 as quickly as possible. */ |
if (ALIGNED (s1)) |
{ |
unsigned long *aligned_s1 = (unsigned long *)s1; |
while (!DETECTNULL (*aligned_s1)) |
aligned_s1++; |
s1 = (char *)aligned_s1; |
} |
while (*s1) |
s1++; |
/* s1 now points to the its trailing null character, we can |
just use strcpy to do the work for us now. |
?!? We might want to just include strcpy here. |
Also, this will cause many more unaligned string copies because |
s1 is much less likely to be aligned. I don't know if its worth |
tweaking strcpy to handle this better. */ |
strcpy (s1, s2); |
return s; |
#endif /* not PREFER_SIZE_OVER_SPEED */ |
} |
/programs/develop/libraries/newlib/string/strcoll.c |
---|
0,0 → 1,48 |
/* |
FUNCTION |
<<strcoll>>---locale-specific character string compare |
INDEX |
strcoll |
ANSI_SYNOPSIS |
#include <string.h> |
int strcoll(const char *<[stra]>, const char * <[strb]>); |
TRAD_SYNOPSIS |
#include <string.h> |
int strcoll(<[stra]>, <[strb]>) |
char *<[stra]>; |
char *<[strb]>; |
DESCRIPTION |
<<strcoll>> compares the string pointed to by <[stra]> to |
the string pointed to by <[strb]>, using an interpretation |
appropriate to the current <<LC_COLLATE>> state. |
RETURNS |
If the first string is greater than the second string, |
<<strcoll>> returns a number greater than zero. If the two |
strings are equivalent, <<strcoll>> returns zero. If the first |
string is less than the second string, <<strcoll>> returns a |
number less than zero. |
PORTABILITY |
<<strcoll>> is ANSI C. |
<<strcoll>> requires no supporting OS subroutines. |
QUICKREF |
strcoll ansi pure |
*/ |
#include <string.h> |
int |
_DEFUN (strcoll, (a, b), |
_CONST char *a _AND |
_CONST char *b) |
{ |
return strcmp (a, b); |
} |
/programs/develop/libraries/newlib/string/strncat.c |
---|
0,0 → 1,114 |
/* |
FUNCTION |
<<strncat>>---concatenate strings |
INDEX |
strncat |
ANSI_SYNOPSIS |
#include <string.h> |
char *strncat(char *<[dst]>, const char *<[src]>, size_t <[length]>); |
TRAD_SYNOPSIS |
#include <string.h> |
char *strncat(<[dst]>, <[src]>, <[length]>) |
char *<[dst]>; |
char *<[src]>; |
size_t <[length]>; |
DESCRIPTION |
<<strncat>> appends not more than <[length]> characters from |
the string pointed to by <[src]> (including the terminating |
null character) to the end of the string pointed to by |
<[dst]>. The initial character of <[src]> overwrites the null |
character at the end of <[dst]>. A terminating null character |
is always appended to the result |
WARNINGS |
Note that a null is always appended, so that if the copy is |
limited by the <[length]> argument, the number of characters |
appended to <[dst]> is <<n + 1>>. |
RETURNS |
This function returns the initial value of <[dst]> |
PORTABILITY |
<<strncat>> is ANSI C. |
<<strncat>> requires no supporting OS subroutines. |
QUICKREF |
strncat ansi pure |
*/ |
#include <string.h> |
#include <limits.h> |
/* Nonzero if X is aligned on a "long" boundary. */ |
#define ALIGNED(X) \ |
(((long)X & (sizeof (long) - 1)) == 0) |
#if LONG_MAX == 2147483647L |
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080) |
#else |
#if LONG_MAX == 9223372036854775807L |
/* Nonzero if X (a long int) contains a NULL byte. */ |
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080) |
#else |
#error long int is not a 32bit or 64bit type. |
#endif |
#endif |
#ifndef DETECTNULL |
#error long int is not a 32bit or 64bit byte |
#endif |
char * |
_DEFUN (strncat, (s1, s2, n), |
char *s1 _AND |
_CONST char *s2 _AND |
size_t n) |
{ |
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__) |
char *s = s1; |
while (*s1) |
s1++; |
while (n-- != 0 && (*s1++ = *s2++)) |
{ |
if (n == 0) |
*s1 = '\0'; |
} |
return s; |
#else |
char *s = s1; |
/* Skip over the data in s1 as quickly as possible. */ |
if (ALIGNED (s1)) |
{ |
unsigned long *aligned_s1 = (unsigned long *)s1; |
while (!DETECTNULL (*aligned_s1)) |
aligned_s1++; |
s1 = (char *)aligned_s1; |
} |
while (*s1) |
s1++; |
/* s1 now points to the its trailing null character, now copy |
up to N bytes from S2 into S1 stopping if a NULL is encountered |
in S2. |
It is not safe to use strncpy here since it copies EXACTLY N |
characters, NULL padding if necessary. */ |
while (n-- != 0 && (*s1++ = *s2++)) |
{ |
if (n == 0) |
*s1 = '\0'; |
} |
return s; |
#endif /* not PREFER_SIZE_OVER_SPEED */ |
} |
/programs/develop/libraries/newlib/string/strndup.c |
---|
0,0 → 1,16 |
#ifndef _REENT_ONLY |
#include <_ansi.h> |
#include <reent.h> |
#include <stdlib.h> |
#include <string.h> |
char * |
_DEFUN (strndup, (str, n), |
_CONST char *str _AND |
size_t n) |
{ |
return _strndup_r (_REENT, str, n); |
} |
#endif /* !_REENT_ONLY */ |
/programs/develop/libraries/newlib/string/strndup_r.c |
---|
0,0 → 1,27 |
#include <reent.h> |
#include <stdlib.h> |
#include <string.h> |
char * |
_DEFUN (_strndup_r, (reent_ptr, str, n), |
struct _reent *reent_ptr _AND |
_CONST char *str _AND |
size_t n) |
{ |
_CONST char *ptr = str; |
size_t len; |
char *copy; |
while (n-- > 0 && *ptr) |
ptr++; |
len = ptr - str; |
copy = _malloc_r (reent_ptr, len + 1); |
if (copy) |
{ |
memcpy (copy, str, len); |
copy[len] = '\0'; |
} |
return copy; |
} |
/programs/develop/libraries/newlib/string/strpbrk.c |
---|
0,0 → 1,58 |
/* |
FUNCTION |
<<strpbrk>>---find characters in string |
INDEX |
strpbrk |
ANSI_SYNOPSIS |
#include <string.h> |
char *strpbrk(const char *<[s1]>, const char *<[s2]>); |
TRAD_SYNOPSIS |
#include <string.h> |
char *strpbrk(<[s1]>, <[s2]>) |
char *<[s1]>; |
char *<[s2]>; |
DESCRIPTION |
This function locates the first occurence in the string |
pointed to by <[s1]> of any character in string pointed to by |
<[s2]> (excluding the terminating null character). |
RETURNS |
<<strpbrk>> returns a pointer to the character found in <[s1]>, or a |
null pointer if no character from <[s2]> occurs in <[s1]>. |
PORTABILITY |
<<strpbrk>> requires no supporting OS subroutines. |
*/ |
#include <string.h> |
char * |
_DEFUN (strpbrk, (s1, s2), |
_CONST char *s1 _AND |
_CONST char *s2) |
{ |
_CONST char *c = s2; |
if (!*s1) |
return (char *) NULL; |
while (*s1) |
{ |
for (c = s2; *c; c++) |
{ |
if (*s1 == *c) |
break; |
} |
if (*c) |
break; |
s1++; |
} |
if (*c == '\0') |
s1 = NULL; |
return (char *) s1; |
} |
/programs/develop/libraries/newlib/string/strsep.c |
---|
0,0 → 1,19 |
/* BSD strsep function */ |
/* Copyright 2002, Red Hat Inc. */ |
/* undef STRICT_ANSI so that strsep prototype will be defined */ |
#undef __STRICT_ANSI__ |
#include <string.h> |
#include <_ansi.h> |
#include <reent.h> |
extern char *__strtok_r (char *, const char *, char **, int); |
char * |
_DEFUN (strsep, (source_ptr, delim), |
register char **source_ptr _AND |
register const char *delim) |
{ |
return __strtok_r (*source_ptr, delim, source_ptr, 0); |
} |
/programs/develop/libraries/newlib/string/strtok.c |
---|
0,0 → 1,101 |
/* |
FUNCTION |
<<strtok>>, <<strtok_r>>, <<strsep>>---get next token from a string |
INDEX |
strtok |
INDEX |
strtok_r |
INDEX |
strsep |
ANSI_SYNOPSIS |
#include <string.h> |
char *strtok(char *<[source]>, const char *<[delimiters]>) |
char *strtok_r(char *<[source]>, const char *<[delimiters]>, |
char **<[lasts]>) |
char *strsep(char **<[source_ptr]>, const char *<[delimiters]>) |
TRAD_SYNOPSIS |
#include <string.h> |
char *strtok(<[source]>, <[delimiters]>) |
char *<[source]>; |
char *<[delimiters]>; |
char *strtok_r(<[source]>, <[delimiters]>, <[lasts]>) |
char *<[source]>; |
char *<[delimiters]>; |
char **<[lasts]>; |
char *strsep(<[source_ptr]>, <[delimiters]>) |
char **<[source_ptr]>; |
char *<[delimiters]>; |
DESCRIPTION |
The <<strtok>> function is used to isolate sequential tokens in a |
null-terminated string, <<*<[source]>>>. These tokens are delimited |
in the string by at least one of the characters in <<*<[delimiters]>>>. |
The first time that <<strtok>> is called, <<*<[source]>>> should be |
specified; subsequent calls, wishing to obtain further tokens from |
the same string, should pass a null pointer instead. The separator |
string, <<*<[delimiters]>>>, must be supplied each time and may |
change between calls. |
The <<strtok>> function returns a pointer to the beginning of each |
subsequent token in the string, after replacing the separator |
character itself with a null character. When no more tokens remain, |
a null pointer is returned. |
The <<strtok_r>> function has the same behavior as <<strtok>>, except |
a pointer to placeholder <<*<[lasts]>>> must be supplied by the caller. |
The <<strsep>> function is similar in behavior to <<strtok>>, except |
a pointer to the string pointer must be supplied <<<[source_ptr]>>> and |
the function does not skip leading delimiters. When the string starts |
with a delimiter, the delimiter is changed to the null character and |
the empty string is returned. Like <<strtok_r>> and <<strtok>>, the |
<<*<[source_ptr]>>> is updated to the next character following the |
last delimiter found or NULL if the end of string is reached with |
no more delimiters. |
RETURNS |
<<strtok>>, <<strtok_r>>, and <<strsep>> all return a pointer to the |
next token, or <<NULL>> if no more tokens can be found. For |
<<strsep>>, a token may be the empty string. |
NOTES |
<<strtok>> is unsafe for multi-threaded applications. <<strtok_r>> |
and <<strsep>> are thread-safe and should be used instead. |
PORTABILITY |
<<strtok>> is ANSI C. |
<<strtok_r>> is POSIX. |
<<strsep>> is a BSD extension. |
<<strtok>>, <<strtok_r>>, and <<strsep>> require no supporting OS subroutines. |
QUICKREF |
strtok ansi impure |
*/ |
/* undef STRICT_ANSI so that strtok_r prototype will be defined */ |
#undef __STRICT_ANSI__ |
#include <string.h> |
#include <_ansi.h> |
#include <reent.h> |
#ifndef _REENT_ONLY |
extern char *__strtok_r (char *, const char *, char **, int); |
char * |
_DEFUN (strtok, (s, delim), |
register char *s _AND |
register const char *delim) |
{ |
_REENT_CHECK_MISC(_REENT); |
return __strtok_r (s, delim, &(_REENT_STRTOK_LAST(_REENT)), 1); |
} |
#endif |
/programs/develop/libraries/newlib/string/strtok_r.c |
---|
0,0 → 1,99 |
/* |
* Copyright (c) 1988 Regents of the University of California. |
* All rights reserved. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* 1. Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* 2. 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. |
* 3. Neither the name of the University nor the names of its contributors |
* may be used to endorse or promote products derived from this software |
* without specific prior written permission. |
* |
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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. |
*/ |
#include <string.h> |
char * |
_DEFUN (__strtok_r, (s, delim, lasts, skip_leading_delim), |
register char *s _AND |
register const char *delim _AND |
char **lasts _AND |
int skip_leading_delim) |
{ |
register char *spanp; |
register int c, sc; |
char *tok; |
if (s == NULL && (s = *lasts) == NULL) |
return (NULL); |
/* |
* Skip (span) leading delimiters (s += strspn(s, delim), sort of). |
*/ |
cont: |
c = *s++; |
for (spanp = (char *)delim; (sc = *spanp++) != 0;) { |
if (c == sc) { |
if (skip_leading_delim) { |
goto cont; |
} |
else { |
*lasts = s; |
s[-1] = 0; |
return (s - 1); |
} |
} |
} |
if (c == 0) { /* no non-delimiter characters */ |
*lasts = NULL; |
return (NULL); |
} |
tok = s - 1; |
/* |
* Scan token (scan for delimiters: s += strcspn(s, delim), sort of). |
* Note that delim must have one NUL; we stop if we see that, too. |
*/ |
for (;;) { |
c = *s++; |
spanp = (char *)delim; |
do { |
if ((sc = *spanp++) == c) { |
if (c == 0) |
s = NULL; |
else |
s[-1] = 0; |
*lasts = s; |
return (tok); |
} |
} while (sc != 0); |
} |
/* NOTREACHED */ |
} |
char * |
_DEFUN (strtok_r, (s, delim, lasts), |
register char *s _AND |
register const char *delim _AND |
char **lasts) |
{ |
return __strtok_r (s, delim, lasts, 1); |
} |
/programs/develop/libraries/newlib/string/strupr.c |
---|
0,0 → 1,46 |
/* |
FUNCTION |
<<strupr>>---force string to uppercase |
INDEX |
strupr |
ANSI_SYNOPSIS |
#include <string.h> |
char *strupr(char *<[a]>); |
TRAD_SYNOPSIS |
#include <string.h> |
char *strupr(<[a]>) |
char *<[a]>; |
DESCRIPTION |
<<strupr>> converts each character in the string at <[a]> to |
uppercase. |
RETURNS |
<<strupr>> returns its argument, <[a]>. |
PORTABILITY |
<<strupr>> is not widely portable. |
<<strupr>> requires no supporting OS subroutines. |
QUICKREF |
strupr |
*/ |
#include <string.h> |
#include <ctype.h> |
char * |
_DEFUN (strupr, (s), |
char *s) |
{ |
unsigned char *ucs = (unsigned char *) s; |
for ( ; *ucs != '\0'; ucs++) |
{ |
*ucs = toupper(*ucs); |
} |
return s; |
} |