01c,25feb93,jdi  documentation cleanup for 5.1.01b,20sep92,smb  documentation additions01a,08jul92,smb  written and documented.*//*DESCRIPTIONINCLUDE FILES: string.hSEE ALSO: American National Standard X3.159-1989NOMANUAL*/#include "vxWorks.h"#include "string.h"/********************************************************************************* strpbrk - find the first occurrence in a string of a character from a given set (ANSI)** This routine locates the first occurrence in string <s1> of any character* from string <s2>.** INCLUDE FILES: string.h** RETURNS:* A pointer to the character found in <s1>, or* NULL if no character from <s2> occurs in <s1>.** SEE ALSO: strcspn()*/char * strpbrk    (    const char * s1,       /* string to search */    const char * s2        /* set of characters to look for in <s1> */    )    {    char *scanp;    int   c;    int   sc;    while ((c = *s1++) != 0)			/* wait until end of string */	{	/* loop, searching for character */	for (scanp = CHAR_FROM_CONST(s2); (sc = *scanp++) != 0;)	    {	    if (sc == c)		return (CHAR_FROM_CONST(s1 - 1));	    }	}    return (NULL);    }/* strrchr.c - string search, string *//* Copyright 1992-1993 Wind River Systems, Inc. *//*modification history--------------------01c,25feb93,jdi  documentation cleanup for 5.1.01b,20sep92,smb  documentation additions01a,08jul92,smb  written and documented.*//*DESCRIPTIONINCLUDE FILES: string.hSEE ALSO: American National Standard X3.159-1989NOMANUAL*/#include "vxWorks.h"#include "string.h"/******************************************************************************** strrchr - find the last occurrence of a character in a string (ANSI)** This routine locates the last occurrence of <c> in the string pointed* to by <s>.  The terminating null is considered to be part of the string.** INCLUDE FILES: string.h** RETURNS:* A pointer to the last occurrence of the character, or* NULL if the character is not found.*/char * strrchr    (    const char * s,         /* string to search */    int          c          /* character to look for */    )    {    char *save = NULL;    do					/* loop, searching for character */	{	if (*s == (char) c)	    save = CHAR_FROM_CONST (s);        } while (*s++ != EOS);    return (CHAR_FROM_CONST(save));    }/* strspn.c - string search, string *//* Copyright 1992-1993 Wind River Systems, Inc. *//*modification history--------------------01c,25feb93,jdi  documentation cleanup for 5.1.01b,20sep92,smb  documentation additions01a,08jul92,smb  written and documented.*//*DESCRIPTIONINCLUDE FILES: string.hSEE ALSO: American National Standard X3.159-1989NOMANUAL*/#include "vxWorks.h"#include "string.h"/******************************************************************************** strspn - return the string length up to the first character not in a given set (ANSI)** This routine computes the length of the maximum initial segment of* string <s> that consists entirely of characters from the string <sep>.** INCLUDE FILES: string.h** RETURNS:* The length of the string segment.** SEE ALSO: strcspn()*/ size_t strspn    (    const char * s,             /* string to search */    const char * sep            /* set of characters to look for in <s> */    )    {    const char *save;    const char *p;    char c1;    char c2;    for (save = s + 1; (c1 = *s++) != EOS; )	for (p = sep; (c2 = *p++) != c1; )	    {	    if (c2 == EOS)		return (s - save);            }    return (s - save);    }/* strstr.c - file for string *//* Copyright 1992-1993 Wind River Systems, Inc. *//*modification history--------------------01c,25feb93,jdi  documentation cleanup for 5.1.01b,20sep92,smb  documentation additions01a,08jul92,smb  written and documented.*//*DESCRIPTIONINCLUDE FILES: string.hSEE ALSO: American National Standard X3.159-1989NOMANUAL*/#include "vxWorks.h"#include "string.h"/******************************************************************************** strstr - find the first occurrence of a substring in a string (ANSI)** This routine locates the first occurrence in string <s>* of the sequence of characters (excluding the terminating null character)* in the string <find>.** INCLUDE FILES: string.h** RETURNS:* A pointer to the located substring, or <s> if <find> points to a* zero-length string, or NULL if the string is not found.*/char * strstr    (    const char * s,        /* string to search */    const char * find      /* substring to look for */    )    {    char *t1;    char *t2;    char c;    char c2;    if ((c = *find++) == EOS)		/* <find> an empty string */	return (CHAR_FROM_CONST(s));    FOREVER	{	while (((c2 = *s++) != EOS) && (c2 != c))	    ;	if (c2 == EOS)	    return (NULL);	t1 = CHAR_FROM_CONST(s);	t2 = CHAR_FROM_CONST(find); 	while (((c2 = *t2++) != 0) && (*t1++ == c2))	    ;	if (c2 == EOS)	    return (CHAR_FROM_CONST(s - 1));	}    }/* strtok.c - file for string *//* Copyright 1992-1995 Wind River Systems, Inc. *//*modification history--------------------01d,23oct95,jdi  doc: added comment that input string will be		    changed (SPR 4874).01c,25feb93,jdi  documentation cleanup for 5.1.01b,20sep92,smb  documentation additions01a,08jul92,smb  written and documented.*//*DESCRIPTIONINCLUDE FILES: string.hSEE ALSO: American National Standard X3.159-1989NOMANUAL*/#include "vxWorks.h"#include "string.h"/******************************************************************************** strtok - break down a string into tokens (ANSI)** A sequence of calls to this routine breaks the string <string> into a* sequence of tokens, each of which is delimited by a character from the* string <separator>.  The first call in the sequence has <string> as its* first argument, and is followed by calls with a null pointer as their* first argument.  The separator string may be different from call to call.* * The first call in the sequence searches <string> for the first character* that is not contained in the current separator string.  If the character* is not found, there are no tokens in <string> and strtok() returns a* null pointer.  If the character is found, it is the start of the first* token.* * strtok() then searches from there for a character that is contained in the* current separator string.  If the character is not found, the current* token expands to the end of the string pointed to by <string>, and* subsequent searches for a token will return a null pointer.  If the* character is found, it is overwritten by a null character, which* terminates the current token.  strtok() saves a pointer to the following* character, from which the next search for a token will start.* (Note that because the separator character is overwritten by a null* character, the input string is modified as a result of this call.)* * Each subsequent call, with a null pointer as the value of the first* argument, starts searching from the saved pointer and behaves as* described above.* * The implementation behaves as if strtok() is called by no library functions.** REENTRANCY* This routine is not reentrant; the reentrant form is strtok_r().** INCLUDE FILES: string.h* * RETURNS* A pointer to the first character of a token, or a NULL pointer if there is* no token.** SEE ALSO: strtok_r()*/ char * strtok    (    char *       string,	/* string */    const char * separator	/* separator indicator */    )    {    static char *last = NULL;    return (strtok_r (string, separator, &last));    }/* strtok_r.c - file for string *//* Copyright 1992-1995 Wind River Systems, Inc. *//*modification history--------------------01d,23oct95,jdi  doc: added comment that input string will be		    changed (SPR 4874).01c,25feb93,jdi  documentation cleanup for 5.1.01b,20sep92,smb  documentation additions01a,08jul92,smb  written and documented.*//*DESCRIPTIONINCLUDE FILES: string.hSEE ALSO: American National Standard X3.159-1989NOMANUAL*/#include "vxWorks.h"#include "string.h"/******************************************************************************* strtok_r - break down a string into tokens (reentrant) (POSIX)** This routine considers the null-terminated string <string> as a sequence* of zero or more text tokens separated by spans of one or more characters* from the separator string <separators>.  The argument <ppLast> points to a* user-provided pointer which in turn points to the position within <string>* at which scanning should begin.** In the first call to this routine, <string> points to a null-terminated* string; <separators> points to a null-terminated string of separator* characters; and <ppLast> points to a NULL pointer.  The function returns a* pointer to the first character of the first token, writes a null character* into <string> immediately following the returned token, and updates the* pointer to which <ppLast> points so that it points to the first character* following the null written into <string>.  (Note that because the* separator character is overwritten by a null character, the input string* is modified as a result of this call.)** In subsequent calls <string> must be a NULL pointer and <ppLast> must* be unchanged so that subsequent calls will move through the string <string>,* returning successive tokens until no tokens remain.  The separator* string <separators> may be different from call to call.  When no token* remains in <string>, a NULL pointer is returned.** INCLUDE FILES: string.h* * RETURNS* A pointer to the first character of a token,* or a NULL pointer if there is no token.** SEE ALSO: strtok()*/char * strtok_r    (    char *       string,	/* string to break into tokens */    const char * separators,	/* the separators */    char **      ppLast		/* pointer to serve as string index */    )    {    if ((string == NULL) && ((string = *ppLast) == NULL))	return (NULL);    if (*(string += strspn (string, separators)) == EOS)	return (*ppLast = NULL);    if ((*ppLast = strpbrk (string, separators)) != NULL)	*(*ppLast)++ = EOS;    return (string);    }/* strxfrm.c - file for string *//* Copyright 1992-1993 Wind River Systems, Inc. *//*modification history--------------------01d,25feb93,jdi  documentation cleanup for 5.1.01c,20sep92,smb  documentation additions01b,13jul92,smb  changed __cosave initialisation for MIPS.01a,08jul92,smb  written and documented.*//*DESCRIPTIONINCLUDE FILES: string.hSEE ALSO: American National Standard X3.159-1989NOMANUAL*/#include "vxWorks.h"#include "limits.h"#include "private/strxfrmP.h"/********************************************************************************* strxfrm - transform up to <n> characters of <s2> into <s1> (ANSI)** This routine transforms string <s2> and places the resulting string in <s1>.* The transformation is such that if strcmp() is applied to two transformed* strings, it returns a value greater than, equal to, or less than zero,* corresponding to the result of the strcoll() function applied to the same* two original strings.  No more than <n> characters are placed into the* resulting <s1>, including the terminating null character.  If <n> is zero,* <s1> is permitted to be a NULL pointer.  If copying takes place between* objects that overlap, the behavior is undefined.** INCLUDE FILES: string.h** RETURNS:* The length of the transformed string, not including the terminating null* character.  If the value is <n> or more, the contents of <s1> are* indeterminate.** SEE ALSO: strcmp(), strcoll()*/size_t strxfrm    (    char *	 s1,		/* string out */    const char * s2,		/* string in */    size_t  	 n		/* size of buffer */    )    {    size_t	   i;    size_t	   nx = 0;    const uchar_t *s = (const uchar_t *)s2;    char	   buf[32];    __cosave 	   state;    /* stores state information */    state.__state = EOS;    state.__wchar = 0;    while (nx < n)				/* translate and deliver */    	{    	i = __strxfrm (s1, &s, nx - n, &state);    	s1 += i; 	nx += i;    	if ((i > 0) && (s1[-1] == EOS))	    return (nx - 1);    	if (*s == EOS)	    s = (const uchar_t *) s2;    	}    FOREVER					/* translate the rest */     	{    	i = __strxfrm (buf, &s, sizeof (buf), &state);    	nx += i;    	if ((i > 0) && (buf [i - 1] == EOS))	    return (nx - 1);    	if (*s == EOS)	    s = (const uchar_t *) s2;    	}    }/*********************************************************************************  __strxfrm - translates string into an easier form for strxfrm() and strcoll()** This routine performs the mapping as a finite state machine executing* the table __wcstate defined in xstate.h.** NOMANUAL*/size_t __strxfrm    (    char *	  	sout,		/* out string */    const uchar_t **	ppsin,		/* pointer to character within string */    size_t 		size,		/* size of string */    __cosave *		ps		/* state information */    )    {    const ushort_t *	stab;    ushort_t	 	code;    char 		state = ps->__state;	/* initial state */    BOOL 		leave = FALSE;    int 		limit = 0;    int 		nout = 0;    const uchar_t *	sin = *ppsin;		/* in string */    ushort_t		wc = ps->__wchar;    FOREVER					/* do state transformation */    	{	    	if ((_NSTATE <= state) ||    	    ((stab = __costate.__table [state]) == NULL) ||    	    ((code = stab [*sin]) == 0))    	    break;		/* error */    	state = (code & ST_STATE) >> ST_STOFF;    	if ( code & ST_FOLD)    		wc = wc & ~UCHAR_MAX | code & ST_CH;    	if ( code & ST_ROTATE)    		wc = wc >> CHAR_BIT & UCHAR_MAX | wc << CHAR_BIT;    	if ((code & ST_OUTPUT) &&    	    (((sout[nout++] = code & ST_CH ? code : wc) == EOS) ||    	    (size <= nout)))    		leave = TRUE;    	if (code & ST_INPUT)    	    if (*sin != EOS)	        {    	        ++sin; 	        limit = 0;	        }    	    else    	    	leave = TRUE;    	if (leave)    	    {		/* save state and return */    	    *ppsin = sin;    	    ps->__state = state;    	    ps->__wchar = wc;    	    return (nout);    	    }    	}    sout[nout++] = EOS;		/* error */    *ppsin = sin;    ps->__state = _NSTATE;    return (nout);    }