/* ansiString.c - ANSI `string' documentation *//* Copyright 1992-1995 Wind River Systems, Inc. *//*modification history--------------------01f,11jul97,dgp  doc: SPR 7651 need list of non-reentrant functions01e,23oct95,jdi  doc: incorporated changes for strtok() & strtok_r() (SPR 4874).01d,11feb95,jdi  fixed size parameter name in doc for memset().01c,25feb93,jdi  documentation cleanup for 5.1.01b,30nov92,jdi  fixed doc for strerror() - SPR 1825.01a,24oct92,smb  written*//*DESCRIPTIONThis library includes several standard ANSI routines.  Note that wherethere is a pair of routines, such as div() and div_r(), only the routinexxx_r() is reentrant.  The xxx() routine is not reentrant. The header string.h declares one type and several functions, and defines onemacro useful for manipulating arrays of character type and other objectstreated as array of character type.  The type is `size_t' and the macro NULL.Various methods are used for determining the lengths of the arrays, but inall cases a `char *' or `void *' argument points to the initial (lowestaddressed) character of the array.  If an array is accessed beyond the endof an object, the behavior is undefined.SEE ALSO: American National Standard X3.159-1989INTERNALThis documentation module is built by appending the following files:    memchr.c    memcmp.c    memcpy.c    memmove.c    memset.c    strcat.c    strchr.c    strcmp.c    strcoll.c    strcpy.c    strcspn.c    strerror.c    strlen.c    strncat.c    strncmp.c    strncpy.c    strpbrk.c    strrchr.c    strspn.c    strstr.c    strtok.c    strtok_r.c    strxfrm.c*//* memchr.c - search memory for a character, 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"/********************************************************************************* memchr - search a block of memory for a character (ANSI)** This routine searches for the first element of an array of `unsigned char',* beginning at the address <m> with size <n>, that equals <c> converted to* an `unsigned char'.** INCLUDE FILES: string.h** RETURNS: If successful, it returns the address of the matching element;* otherwise, it returns a null pointer.*/void * memchr    (    const void * m,		/* block of memory */    int 	 c,		/* character to search for */    size_t 	 n		/* size of memory to search */    )    {    uchar_t *p = (uchar_t *) CHAR_FROM_CONST(m);    if (n != 0)	do 	    {	    if (*p++ == (unsigned char) c)		return (VOID_FROM_CONST(p - 1));	    } while (--n != 0);    return (NULL);    }/* memcmp.c - memory compare 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 FILE: string.hSEE ALSO: American National Standard X3.159-1989NOMANUAL*/#include "vxWorks.h"#include "string.h"/********************************************************************************* memcmp - compare two blocks of memory (ANSI)** This routine compares successive elements from two arrays of `unsigned char',* beginning at the addresses <s1> and <s2> (both of size <n>), until it finds* elements that are not equal.** INCLUDE FILES: string.h** RETURNS:* If all elements are equal, zero.  If elements differ and the differing* element from <s1> is greater than the element from <s2>, the routine* returns a positive number; otherwise, it returns a negative number.*/int memcmp    (    const void * s1,		/* array 1 */    const void * s2,		/* array 2 */    size_t       n		/* size of memory to compare */    )    {    const unsigned char *p1;    const unsigned char *p2;    /* size of memory is zero */    if (n == 0)	return (0);    /* compare array 2 into array 1 */    p1 = s1;    p2 = s2;    while (*p1++ == *p2++)	{	if (--n == 0)	    return (0);        }    return ((*--p1) - (*--p2));    }/* memcpy.c - memory copy file for string *//* Copyright 1992-1993 Wind River Systems, Inc. *//*modification history--------------------01g,25feb93,jdi  documentation cleanup for 5.1.01f,20sep92,smb  documentation additions01e,14sep92,smb  memcpy again uses bcopy01d,07sep92,smb  changed so that memcpy is seperate from bcopy.01c,30jul92,smb  changed to use bcopy.01b,12jul92,smb  changed post decrements to pre decrements.01a,08jul92,smb  written and documented.           +rrr*//*DESCRIPTIONINCLUDE FILES: string.hSEE ALSO: American National Standard X3.159-1989NOMANUAL*/#include "vxWorks.h"#include "string.h"/********************************************************************************* memcpy - copy memory from one location to another (ANSI)** This routine copies <size> characters from the object pointed* to by <source> into the object pointed to by <destination>. If copying* takes place between objects that overlap, the behavior is undefined.** INCLUDE FILES: string.h** RETURNS: A pointer to <destination>.*/void * memcpy    (    void *       destination,   /* destination of copy */    const void * source,        /* source of copy */    size_t       size           /* size of memory to copy */    )    {    bcopy ((char *) source, (char *) destination, (size_t) size);    return (destination);    }/* memmove.c - memory move 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"/********************************************************************************* memmove - copy memory from one location to another (ANSI)** This routine copies <size> characters from the memory location <source> to* the location <destination>.  It ensures that the memory is not corrupted* even if <source> and <destination> overlap.** INCLUDE FILES: string.h** RETURNS: A pointer to <destination>.*/void * memmove    (    void *	 destination,	/* destination of copy */    const void * source,	/* source of copy */    size_t 	 size		/* size of memory to copy */    )    {    char *	dest;    const char *src;    dest = destination;    src = source;    if ((src < dest) && (dest < (src + size)))	{	for (dest += size, src += size; size > 0; --size)	    *--dest = *--src;        }    else 	{	while (size > 0)	    {	    size--;	    *dest++ = *src++;	    }        }    return (destination);    }/* memset.c - set a block of memory, string *//* Copyright 1992-1995 Wind River Systems, Inc. *//*modification history--------------------01g,11feb95,jdi  fixed size parameter name in doc.01f,25feb93,jdi  documentation cleanup for 5.1.01e,20sep92,smb  documentation additions01d,14sep92,smb  changes back to use bfill.01c,07sep92,smb  changed so that memset is seperate from bfill01b,30jul92,smb  changes to use bfill.01a,08jul92,smb  written and documented.           +rrr*//*DESCRIPTIONINCLUDE FILES: string.hSEE ALSO: American National Standard X3.159-1989NOMANUAL*/#include "vxWorks.h"#include "string.h"/********************************************************************************* memset - set a block of memory (ANSI)** This routine stores <c> converted to an `unsigned char' in each of the* elements of the array of `unsigned char' beginning at <m>, with size <size>.** INCLUDE FILES: string.h** RETURNS: A pointer to <m>.*/void * memset    (    void * m,                   /* block of memory */    int    c,                   /* character to store */    size_t size                 /* size of memory */    )    {    bfill ((char *) m, (int) size, c);    return (m);    }/* strcat.c - concatenate one string to another, 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"/********************************************************************************* strcat - concatenate one string to another (ANSI)** This routine appends a copy of string <append> to the end of string * <destination>.  The resulting string is null-terminated.** INCLUDE FILES: string.h** RETURNS: A pointer to <destination>.*/char * strcat    (    char *       destination, /* string to be appended to */    const char * append       /* string to append to <destination> */    )    {    char *save = destination;    while (*destination++ != '\0')		/* find end of string */        ;    destination--;    while ((*destination++ = *append++) != '\0')	;    return (save);    }/* strchr.c - search string for character, 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"/******************************************************************************** strchr - find the first occurrence of a character in a string (ANSI)** This routine finds the first occurrence of character <c>* in string <s>.  The terminating null is considered to be part of the string.** INCLUDE FILES: string.h** RETURNS:* The address of the located character, or NULL if the character is not found.*/char * strchr    (    const char * s,         /* string in which to search */    int 	 c          /* character to find in string */    )    {    char *r = CHAR_FROM_CONST(s);     while (*r != (char) c)		/* search loop */	{	if (*r++ == EOS)		/* end of string */	    return (NULL);        }    return (r);    }/* strcmp.c - compare two strings, 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"/********************************************************************************* strcmp - compare two strings lexicographically (ANSI)** This routine compares string <s1> to string <s2> lexicographically.** INCLUDE FILES: string.h** RETURNS: An integer greater than, equal to, or less than 0,* according to whether <s1> is lexicographically* greater than, equal to, or less than <s2>, respectively.*/int strcmp    (    const char * s1,   /* string to compare */    const char * s2    /* string to compare <s1> to */    )    {    while (*s1++ == *s2++)	if (s1 [-1] == EOS)	    return (0);    return ((s1 [-1]) - (s2 [-1]));    }/* strcoll.c - string collate, 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 "private/strxfrmP.h"/* The __sctl type describes a data object that holds the information  * needed to process each source string. The internal function getxfrm * calls __strxfrm to update an sctl data object. */typedef struct     {    char 	   buf[32];    const uchar_t *s1;    const uchar_t *s2;    const uchar_t *sout;    __cosave       state;    } __sct1;/***************************************************************************** getxfrm - get transformed characters** A conparison loop within strcoll calls getxfrm for each source string that* has no mapped characters in its sctl buffer. This ensures that each source* string is represented by at least one mapped character, if any such* character remains to be generated.** RETURNS: the size of the transformed string* NOMANUAL*/LOCAL size_t getxfrm    (    __sct1 *p	/* information needed to process each source string */    )