/** @file\r
- The header <string.h> declares one type and several functions, and defines\r
- one macro useful for manipulating arrays of character type and other objects\r
- treated as arrays of character type. Various methods are used for\r
- determining the lengths of the arrays, but in all cases a char * or void *\r
- argument points to the initial (lowest addressed) character of the array. If\r
- an array is accessed beyond the end of an object, the behavior is undefined.\r
-\r
- Where an argument declared as size_t n specifies the length of the array for\r
- a function, n can have the value zero on a call to that function. Unless\r
- explicitly stated otherwise in the description of those functions, pointer\r
- arguments on such a call shall still have valid values.\r
-\r
- For all functions declared in this header, each character shall be\r
- interpreted as if it had the type unsigned char (and therefore every possible\r
- object representation is valid and has a different value).\r
-\r
-Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
-This program and the accompanying materials are licensed and made available under\r
-the terms and conditions of the BSD License that accompanies this distribution.\r
-The full text of the license may be found at\r
-http://opensource.org/licenses/bsd-license.php.\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
+ The header <string.h> declares one type and several functions, and defines\r
+ one macro useful for manipulating arrays of character type and other objects\r
+ treated as arrays of character type. Various methods are used for\r
+ determining the lengths of the arrays, but in all cases a char * or void *\r
+ argument points to the initial (lowest addressed) character of the array. If\r
+ an array is accessed beyond the end of an object, the behavior is undefined.\r
+\r
+ Where an argument declared as size_t n specifies the length of the array for\r
+ a function, n can have the value zero on a call to that function. Unless\r
+ explicitly stated otherwise in the description of those functions, pointer\r
+ arguments on such a call must still have valid values.\r
+\r
+ For all functions declared in this header, each character shall be\r
+ interpreted as if it had the type unsigned char (and therefore every possible\r
+ object representation is valid and has a different value).\r
+\r
+ The following macros are defined in this file:<BR>\r
+ @verbatim\r
+ NULL\r
+ bcopy(a,b,c) ( memcpy((void *)b, (const void *)a, (size_t)c))\r
+ bcmp(a,b,c) ( memcmp((void *)a, (void *)b, (size_t)c))\r
+ @endverbatim\r
+\r
+ The following types are defined in this file:<BR>\r
+ @verbatim\r
+ size_t Unsigned integer type of the result of the sizeof operator.\r
+ @endverbatim\r
+\r
+ The following functions are declared in this file:<BR>\r
+ @verbatim\r
+ ################ Copying Functions\r
+ void *memcpy (void * __restrict s1, const void * __restrict s2, size_t n);\r
+ void *memmove (void *s1, const void *s2, size_t n);\r
+ char *strcpy (char * __restrict s1, const char * __restrict s2);\r
+ char *strncpy (char * __restrict s1, const char * __restrict s2, size_t n);\r
+ int strncpyX (char * __restrict s1, const char * __restrict s2, size_t n);\r
+\r
+ ################ Concatenation Functions\r
+ char *strcat (char * __restrict s1, const char * __restrict s2);\r
+ char *strncat (char * __restrict s1, const char * __restrict s2, size_t n);\r
+ int strncatX (char * __restrict s1, const char * __restrict s2, size_t n);\r
+\r
+ ################ Comparison Functions\r
+ int memcmp (const void *s1, const void *s2, size_t n);\r
+ int strcmp (const char *s1, const char *s2);\r
+ int strcoll (const char *s1, const char *s2);\r
+ int strncmp (const char *s1, const char *s2, size_t n);\r
+ size_t strxfrm (char * __restrict s1, const char * __restrict s2, size_t n);\r
+\r
+ ################ Search Functions\r
+ void *memchr (const void *s, int c, size_t n);\r
+ char *strchr (const char *s, int c);\r
+ size_t strcspn (const char *s1, const char *s2);\r
+ char *strpbrk (const char *s1, const char *s2);\r
+ char *strrchr (const char *s, int c);\r
+ size_t strspn (const char *s1 , const char *s2);\r
+ char *strstr (const char *s1 , const char *s2);\r
+ char *strtok (char * __restrict s1, const char * __restrict s2);\r
+\r
+ ################ Miscellaneous Functions\r
+ void *memset (void *s, int c, size_t n);\r
+ char *strerror (int num);\r
+ size_t strlen (const char *);\r
+\r
+ ################ BSD Compatibility Functions\r
+ char *strdup (const char *);\r
+ int strerror_r (int, char *, size_t);\r
+ int strcasecmp (const char *s1, const char *s2);\r
+ void *memccpy (void *, const void *, int, size_t);\r
+ int strncasecmp (const char *s1, const char *s2, size_t n);\r
+ size_t strlcpy (char *destination, const char *source, size_t size);\r
+ size_t strlcat (char *destination, const char *source, size_t size);\r
+ char *strsep (register char **stringp, register const char *delim);\r
+ @endverbatim\r
+\r
+ Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
+ This program and the accompanying materials are licensed and made available under\r
+ the terms and conditions of the BSD License that accompanies this distribution.\r
+ The full text of the license may be found at\r
+ http://opensource.org/licenses/bsd-license.\r
+\r
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
**/\r
#ifndef _STRING_H\r
#define _STRING_H\r
\r
/* ################ Copying Functions ################################# */\r
\r
-/** The memcpy function copies n characters from the object pointed to by s2\r
- into the object pointed to by s1. If copying takes place between objects\r
+/** The memcpy function copies N characters from the object pointed to by Src\r
+ into the object pointed to by Dest. If copying takes place between objects\r
that overlap, the behavior is undefined.\r
\r
- @return The memcpy function returns the value of s1.\r
+ @param[out] Dest Pointer to the destination of the copy operation.\r
+ @param[in] Src Pointer to the Source data to be copied.\r
+ @param[in] N Number of characters (bytes) to be copied.\r
+\r
+ @return The memcpy function returns the value of Dest.\r
**/\r
-void *memcpy(void * __restrict s1, const void * __restrict s2, size_t n);\r
+void *memcpy(void * __restrict Dest, const void * __restrict Src, size_t N);\r
\r
-/** The memmove function copies n characters from the object pointed to by s2\r
- into the object pointed to by s1. Copying takes place as if the n\r
- characters from the object pointed to by s2 are first copied into a\r
- temporary array of n characters that does not overlap the objects pointed\r
- to by s1 and s2, and then the n characters from the temporary array are\r
- copied into the object pointed to by s1.\r
+/** The memmove function copies N characters from the object pointed to by Src\r
+ into the object pointed to by Dest. Copying takes place as if the N\r
+ characters from the object pointed to by Src are first copied into a\r
+ temporary array of N characters that does not overlap the objects pointed\r
+ to by Dest and Src, and then the N characters from the temporary array are\r
+ copied into the object pointed to by Dest.\r
\r
- @return The memmove function returns the value of s1.\r
+ @param[out] Dest Pointer to the destination of the copy operation.\r
+ @param[in] Src Pointer to the Source data to be copied.\r
+ @param[in] N Number of characters (bytes) to be copied.\r
+\r
+ @return The memmove function returns the value of Dest.\r
**/\r
-void *memmove(void *s1, const void *s2, size_t n);\r
+void *memmove(void *Dest, const void *Src, size_t N);\r
\r
-/** The strcpy function copies the string pointed to by s2 (including the\r
- terminating null character) into the array pointed to by s1. If copying\r
+/** The strcpy function copies the string pointed to by Src (including the\r
+ terminating null character) into the array pointed to by Dest. If copying\r
takes place between objects that overlap, the behavior is undefined.\r
\r
- @return The strcpy function returns the value of s1.\r
+ @param[out] Dest Pointer to the destination of the copy operation.\r
+ @param[in] Src Pointer to the Source data to be copied.\r
+\r
+ @return The strcpy function returns the value of Dest.\r
**/\r
-char *strcpy(char * __restrict s1, const char * __restrict s2);\r
+char *strcpy(char * __restrict Dest, const char * __restrict Src);\r
\r
-/** The strncpy function copies not more than n characters (characters that\r
- follow a null character are not copied) from the array pointed to by s2 to\r
- the array pointed to by s1. If copying takes place between objects that\r
+/** The strncpy function copies not more than N characters (characters that\r
+ follow a null character are not copied) from the array pointed to by Src to\r
+ the array pointed to by Dest. If copying takes place between objects that\r
overlap, the behavior is undefined.\r
\r
- If the array pointed to by s2 is a string that is shorter than n\r
+ If the array pointed to by Src is a string that is shorter than N\r
characters, null characters are appended to the copy in the array pointed\r
- to by s1, until n characters in all have been written.\r
+ to by Dest, until N characters in all have been written.\r
\r
- @return The strncpy function returns the value of s1.\r
+ @param[out] Dest Pointer to the destination of the copy operation.\r
+ @param[in] Src Pointer to the Source data to be copied.\r
+ @param[in] N Number of characters (bytes) to be copied.\r
+\r
+ @return The strncpy function returns the value of Dest.\r
**/\r
-char *strncpy(char * __restrict s1, const char * __restrict s2, size_t n);\r
+char *strncpy(char * __restrict Dest, const char * __restrict Src, size_t N);\r
\r
-/** The strncpyX function copies not more than n-1 characters (characters that\r
- follow a null character are not copied) from the array pointed to by s2 to\r
- the array pointed to by s1. Array s1 is guaranteed to be NULL terminated.\r
+/** The strncpyX function copies not more than N-1 characters (characters that\r
+ follow a null character are not copied) from the array pointed to by Src to\r
+ the array pointed to by Dest. Array Dest is guaranteed to be NULL terminated.\r
If copying takes place between objects that overlap,\r
the behavior is undefined.\r
\r
strncpyX exists because normal strncpy does not indicate if the copy was\r
- terminated because of exhausting the buffer or reaching the end of s2.\r
+ terminated because of exhausting the buffer or reaching the end of Src.\r
+\r
+ @param[out] Dest Pointer to the destination of the copy operation.\r
+ @param[in] Src Pointer to the Source data to be copied.\r
+ @param[in] N Number of characters (bytes) to be copied.\r
\r
@return The strncpyX function returns 0 if the copy operation was\r
- terminated because it reached the end of s1. Otherwise,\r
+ terminated because it reached the end of Dest. Otherwise,\r
a non-zero value is returned indicating how many characters\r
- remain in s1.\r
+ remain in Dest.\r
**/\r
-int strncpyX(char * __restrict s1, const char * __restrict s2, size_t n);\r
+int strncpyX(char * __restrict Dest, const char * __restrict Src, size_t N);\r
\r
/* ################ Concatenation Functions ########################### */\r
\r
-/** The strcat function appends a copy of the string pointed to by s2\r
+/** The strcat function appends a copy of the string pointed to by Src\r
(including the terminating null character) to the end of the string pointed\r
- to by s1. The initial character of s2 overwrites the null character at the\r
- end of s1. If copying takes place between objects that overlap, the\r
+ to by Dest. The initial character of Src overwrites the null character at the\r
+ end of Dest. If copying takes place between objects that overlap, the\r
behavior is undefined.\r
\r
- @return The strcat function returns the value of s1.\r
+ @param[out] Dest Pointer to the destination of the concatenation operation.\r
+ @param[in] Src Pointer to the Source data to be concatenated.\r
+\r
+ @return The strcat function returns the value of Dest.\r
**/\r
-char *strcat(char * __restrict s1, const char * __restrict s2);\r
+char *strcat(char * __restrict Dest, const char * __restrict Src);\r
\r
-/** The strncat function appends not more than n characters (a null character\r
+/** The strncat function appends not more than N characters (a null character\r
and characters that follow it are not appended) from the array pointed to\r
- by s2 to the end of the string pointed to by s1. The initial character of\r
- s2 overwrites the null character at the end of s1. A terminating null\r
+ by Src to the end of the string pointed to by Dest. The initial character of\r
+ Src overwrites the null character at the end of Dest. A terminating null\r
character is always appended to the result. If copying takes place\r
between objects that overlap, the behavior is undefined.\r
\r
- @return The strncat function returns the value of s1.\r
+ @param[out] Dest Pointer to the destination of the concatenation operation.\r
+ @param[in] Src Pointer to the Source data to be concatenated.\r
+ @param[in] N Max Number of characters (bytes) to be concatenated.\r
+\r
+ @return The strncat function returns the value of Dest.\r
**/\r
-char *strncat(char * __restrict s1, const char * __restrict s2, size_t n);\r
+char *strncat(char * __restrict Dest, const char * __restrict Src, size_t N);\r
\r
-/** The strncatX function appends not more than n characters (a null character\r
+/** The strncatX function appends not more than N characters (a null character\r
and characters that follow it are not appended) from the array pointed to\r
- by s2 to the end of the string pointed to by s1. The initial character of\r
- s2 overwrites the null character at the end of s1. The result is always\r
+ by Src to the end of the string pointed to by Dest. The initial character of\r
+ Src overwrites the null character at the end of Dest. The result is always\r
terminated with a null character. If copying takes place between objects\r
that overlap, the behavior is undefined.\r
\r
strncatX exists because normal strncat does not indicate if the operation\r
- was terminated because of exhausting n or reaching the end of s2.\r
+ was terminated because of exhausting N or reaching the end of Src.\r
+\r
+ @param[out] Dest Pointer to the destination of the concatenation operation.\r
+ @param[in] Src Pointer to the Source data to be concatenated.\r
+ @param[in] N Max Number of characters (bytes) to be concatenated.\r
\r
@return The strncatX function returns 0 if the operation was terminated\r
- because it reached the end of s1. Otherwise, a non-zero value is\r
- returned indicating how many characters remain in s1.\r
+ because it reached the end of Dest. Otherwise, a non-zero value is\r
+ returned indicating how many characters remain in Dest.\r
**/\r
int strncatX(char * __restrict s1, const char * __restrict s2, size_t n);\r
\r
/* ################ Comparison Functions ############################## */\r
\r
-/** The memcmp function compares the first n characters of the object pointed\r
- to by s1 to the first n characters of the object pointed to by s2.\r
+/** The memcmp function compares the first N characters of the object pointed\r
+ to by S1 to the first N characters of the object pointed to by S2.\r
+\r
+ @param[out] S1 Pointer to the first object to be compared.\r
+ @param[in] S2 Pointer to the object to be compared to S1.\r
+ @param[in] N Max Number of characters (bytes) to be compared.\r
\r
@return The memcmp function returns an integer greater than, equal to, or\r
- less than zero, accordingly as the object pointed to by s1 is\r
- greater than, equal to, or less than the object pointed to by s2.\r
+ less than zero, accordingly as the object pointed to by S1 is\r
+ greater than, equal to, or less than the object pointed to by S2.\r
**/\r
-int memcmp(const void *s1, const void *s2, size_t n);\r
+int memcmp(const void *S1, const void *S2, size_t N);\r
\r
-/** The strcmp function compares the string pointed to by s1 to the string\r
- pointed to by s2.\r
+/** The strcmp function compares the string pointed to by S1 to the string\r
+ pointed to by S2.\r
+\r
+ @param[out] S1 Pointer to the first string to be compared.\r
+ @param[in] S2 Pointer to the string to be compared to S1.\r
\r
@return The strcmp function returns an integer greater than, equal to, or\r
- less than zero, accordingly as the string pointed to by s1 is\r
- greater than, equal to, or less than the string pointed to by s2.\r
+ less than zero, accordingly as the string pointed to by S1 is\r
+ greater than, equal to, or less than the string pointed to by S2.\r
**/\r
-int strcmp(const char *s1, const char *s2);\r
+int strcmp(const char *S1, const char *S2);\r
\r
-/** The strcoll function compares the string pointed to by s1 to the string\r
- pointed to by s2, both interpreted as appropriate to the LC_COLLATE\r
+/** The strcoll function compares the string pointed to by S1 to the string\r
+ pointed to by S2, both interpreted as appropriate to the LC_COLLATE\r
category of the current locale.\r
\r
+ @param[out] S1 Pointer to the first string to be compared.\r
+ @param[in] S2 Pointer to the string to be compared to S1.\r
+\r
@return The strcoll function returns an integer greater than, equal to,\r
- or less than zero, accordingly as the string pointed to by s1 is\r
- greater than, equal to, or less than the string pointed to by s2\r
+ or less than zero, accordingly as the string pointed to by S1 is\r
+ greater than, equal to, or less than the string pointed to by S2\r
when both are interpreted as appropriate to the current locale.\r
**/\r
-int strcoll(const char *s1, const char *s2);\r
+int strcoll(const char *S1, const char *S2);\r
+\r
+/** The strncmp function compares not more than N characters (characters that\r
+ follow a null character are not compared) from the array pointed to by S1\r
+ to the array pointed to by S2.\r
\r
-/** The strncmp function compares not more than n characters (characters that\r
- follow a null character are not compared) from the array pointed to by s1\r
- to the array pointed to by s2.\r
+ @param[out] S1 Pointer to the first object to be compared.\r
+ @param[in] S2 Pointer to the object to be compared to S1.\r
+ @param[in] N Max Number of characters (bytes) to be compared.\r
\r
@return The strncmp function returns an integer greater than, equal to,\r
or less than zero, accordingly as the possibly null-terminated\r
- array pointed to by s1 is greater than, equal to, or less than\r
- the possibly null-terminated array pointed to by s2.\r
+ array pointed to by S1 is greater than, equal to, or less than\r
+ the possibly null-terminated array pointed to by S2.\r
**/\r
-int strncmp(const char *s1, const char *s2, size_t n);\r
+int strncmp(const char *S1, const char *S2, size_t N);\r
\r
-/** The strxfrm function transforms the string pointed to by s2 and places the\r
- resulting string into the array pointed to by s1. The transformation is\r
+/** The strxfrm function transforms the string pointed to by Src and places the\r
+ resulting string into the array pointed to by Dest. The transformation is\r
such that if the strcmp function is applied to two transformed strings, it\r
returns a value greater than, equal to, or less than zero, corresponding to\r
the result of the strcoll function applied to the same two original\r
- strings. No more than n characters are placed into the resulting array\r
- pointed to by s1, including the terminating null character. If n is zero,\r
- s1 is permitted to be a null pointer. If copying takes place between\r
+ strings. No more than N characters are placed into the resulting array\r
+ pointed to by Dest, including the terminating null character. If N is zero,\r
+ Dest is permitted to be a null pointer. If copying takes place between\r
objects that overlap, the behavior is undefined.\r
\r
+ @param[out] Dest Pointer to the object to receive the transformed string.\r
+ @param[in] Src Pointer to the string to be transformed.\r
+ @param[in] N Max Number of characters (bytes) to be transformed.\r
+\r
@return The strxfrm function returns the length of the transformed string\r
(not including the terminating null character). If the value\r
- returned is n or more, the contents of the array pointed to by s1\r
+ returned is N or more, the contents of the array pointed to by Dest\r
are indeterminate.\r
**/\r
-size_t strxfrm(char * __restrict s1, const char * __restrict s2, size_t n);\r
+size_t strxfrm(char * __restrict Dest, const char * __restrict Src, size_t N);\r
\r
/* ################ Search Functions ################################## */\r
\r
-/** The memchr function locates the first occurrence of c (converted to an\r
- unsigned char) in the initial n characters (each interpreted as\r
- unsigned char) of the object pointed to by s.\r
+/** The memchr function locates the first occurrence of C (converted to an\r
+ unsigned char) in the initial N characters (each interpreted as\r
+ unsigned char) of the object pointed to by S.\r
+\r
+ @param[in] S Pointer to the object to be searched.\r
+ @param[in] C The character value to search for.\r
+ @param[in] N Max Number of characters (bytes) to be searched.\r
\r
@return The memchr function returns a pointer to the located character,\r
or a null pointer if the character does not occur in the object.\r
**/\r
-void *memchr(const void *s, int c, size_t n);\r
+void *memchr(const void *S, int C, size_t N);\r
\r
-/** The strchr function locates the first occurrence of c (converted to a char)\r
- in the string pointed to by s. The terminating null character is considered\r
+/** The strchr function locates the first occurrence of C (converted to a char)\r
+ in the string pointed to by S. The terminating null character is considered\r
to be part of the string.\r
\r
+ @param[in] S Pointer to the object to be searched.\r
+ @param[in] C The character value to search for.\r
+\r
@return The strchr function returns a pointer to the located character,\r
or a null pointer if the character does not occur in the string.\r
**/\r
-char *strchr(const char *s, int c);\r
+char *strchr(const char *S, int C);\r
\r
/** The strcspn function computes the length of the maximum initial segment of\r
- the string pointed to by s1 which consists entirely of characters NOT from\r
- the string pointed to by s2.\r
+ the string pointed to by S1 which consists entirely of characters NOT from\r
+ the string pointed to by S2.\r
+\r
+ @param[in] S1 Pointer to the object to be searched.\r
+ @param[in] S2 Pointer to the list of characters to search for.\r
\r
@return The strcspn function returns the length of the segment.\r
**/\r
-size_t strcspn(const char *s1, const char *s2);\r
+size_t strcspn(const char *S1, const char *S2);\r
\r
/** The strpbrk function locates the first occurrence in the string pointed to\r
- by s1 of any character from the string pointed to by s2.\r
+ by S1 of any character from the string pointed to by S2.\r
+\r
+ @param[in] S1 Pointer to the object to be searched.\r
+ @param[in] S2 Pointer to the list of characters to search for.\r
\r
@return The strpbrk function returns a pointer to the character, or a\r
- null pointer if no character from s2 occurs in s1.\r
+ null pointer if no character from S2 occurs in S1.\r
**/\r
-char *strpbrk(const char *s1, const char *s2);\r
+char *strpbrk(const char *S1, const char *S2);\r
\r
-/** The strrchr function locates the last occurrence of c (converted to a char)\r
- in the string pointed to by s. The terminating null character is considered\r
+/** The strrchr function locates the last occurrence of C (converted to a char)\r
+ in the string pointed to by S. The terminating null character is considered\r
to be part of the string.\r
\r
+ @param[in] S Pointer to the object to be searched.\r
+ @param[in] C The character value to search for.\r
+\r
@return The strrchr function returns a pointer to the character, or a\r
- null pointer if c does not occur in the string.\r
+ null pointer if C does not occur in the string.\r
**/\r
-char *strrchr(const char *s, int c);\r
+char *strrchr(const char *S, int C);\r
\r
/** The strspn function computes the length of the maximum initial segment of\r
- the string pointed to by s1 which consists entirely of characters from the\r
- string pointed to by s2.\r
+ the string pointed to by S1 which consists entirely of characters from the\r
+ string pointed to by S2.\r
+\r
+ @param[in] S1 Pointer to the object to be searched.\r
+ @param[in] S2 Pointer to the list of characters to search for.\r
\r
@return The strspn function returns the length of the segment.\r
**/\r
-size_t strspn(const char *s1 , const char *s2);\r
+size_t strspn(const char *S1 , const char *S2);\r
\r
/** The strstr function locates the first occurrence in the string pointed to\r
- by s1 of the sequence of characters (excluding the terminating null\r
- character) in the string pointed to by s2.\r
+ by S1 of the sequence of characters (excluding the terminating null\r
+ character) in the string pointed to by S2.\r
+\r
+ @param[in] S1 Pointer to the object to be searched.\r
+ @param[in] S2 Pointer to the sequence of characters to search for.\r
\r
@return The strstr function returns a pointer to the located string, or a\r
- null pointer if the string is not found. If s2 points to a string\r
- with zero length, the function returns s1.\r
+ null pointer if the string is not found. If S2 points to a string\r
+ with zero length, the function returns S1.\r
**/\r
-char *strstr(const char *s1 , const char *s2);\r
+char *strstr(const char *S1 , const char *S2);\r
+\r
+/** Break a string into a sequence of tokens.\r
\r
-/** A sequence of calls to the strtok function breaks the string pointed to by\r
- s1 into a sequence of tokens, each of which is delimited by a character\r
- from the string pointed to by s2. The first call in the sequence has a\r
+ A sequence of calls to the strtok function breaks the string pointed to by\r
+ S1 into a sequence of tokens, each of which is delimited by a character\r
+ from the string pointed to by S2. The first call in the sequence has a\r
non-null first argument; subsequent calls in the sequence have a null first\r
- argument. The separator string pointed to by s2 may be different from call\r
+ argument. The separator string pointed to by S2 may be different from call\r
to call.\r
\r
- The first call in the sequence searches the string pointed to by s1 for the\r
+ The first call in the sequence searches the string pointed to by S1 for the\r
first character that is not contained in the current separator string\r
- pointed to by s2. If no such character is found, then there are no tokens\r
- in the string pointed to by s1 and the strtok function returns a null\r
+ pointed to by S2. If no such character is found, then there are no tokens\r
+ in the string pointed to by S1 and the strtok function returns a null\r
pointer. If such a character is found, it is the start of the first token.\r
\r
The strtok function then searches from there for a character that is\r
contained in the current separator string. If no such character is found,\r
- the current token extends to the end of the string pointed to by s1, and\r
+ the current token extends to the end of the string pointed to by S1, and\r
subsequent searches for a token will return a null pointer. If such a\r
character is found, it is overwritten by a null character, which terminates\r
the current token. The strtok function saves a pointer to the following\r
argument, starts searching from the saved pointer and behaves as\r
described above.\r
\r
+ @param[in] S1 Pointer to the string to be tokenized.\r
+ @param[in] S2 Pointer to a list of separator characters.\r
+\r
@return The strtok function returns a pointer to the first character of a\r
token, or a null pointer if there is no token.\r
**/\r
-char *strtok(char * __restrict s1, const char * __restrict s2);\r
+char *strtok(char * __restrict S1, const char * __restrict S2);\r
\r
/* ################ Miscellaneous Functions ########################### */\r
\r
-/** The memset function copies the value of c (converted to an unsigned char)\r
- into each of the first n characters of the object pointed to by s.\r
+/** The memset function copies the value of C (converted to an unsigned char)\r
+ into each of the first N characters of the object pointed to by S.\r
+\r
+ @param[out] S Pointer to the first element of the object to be set.\r
+ @param[in] C Value to store in each element of S.\r
+ @param[in] N Number of elements in S to be set.\r
\r
- @return The memset function returns the value of s.\r
+ @return The memset function returns the value of S.\r
**/\r
-void *memset(void *s, int c, size_t n);\r
+void *memset(void *S, int C, size_t N);\r
\r
-/** The strerror function maps the number in errnum to a message string.\r
- Typically, the values for errnum come from errno, but strerror shall map\r
+/** The strerror function maps the number in Num to a message string.\r
+ Typically, the values for Num come from errno, but strerror shall map\r
any value of type int to a message.\r
\r
- The implementation shall behave as if no library function calls the\r
- strerror function.\r
+ @param[in] Num A value to be converted to a message.\r
\r
@return The strerror function returns a pointer to the string, the\r
contents of which are locale specific. The array pointed to\r
- shall not be modified by the program, but may be overwritten by\r
+ must not be modified by the program, but may be overwritten by\r
a subsequent call to the strerror function.\r
**/\r
-char *strerror(int num);\r
+char *strerror(int Num);\r
+\r
+/** The strlen function computes the length of the string pointed to by S.\r
\r
-/** The strlen function computes the length of the string pointed to by s.\r
+ @param[in] S Pointer to the string to determine the length of.\r
\r
@return The strlen function returns the number of characters that\r
precede the terminating null character.\r
**/\r
-size_t strlen(const char *);\r
+size_t strlen(const char *S);\r
\r
\r
/* ################ BSD Compatibility Functions ####################### */\r
int strcasecmp(const char *s1, const char *s2);\r
void *memccpy (void *, const void *, int, size_t);\r
int strncasecmp(const char *s1, const char *s2, size_t n);\r
+size_t strlcpy(char *destination, const char *source, size_t size);\r
+size_t strlcat(char *destination, const char *source, size_t size);\r
\r
-// bcopy is same as memcpy but it is a void function, being used in socket lib\r
-#define bcopy(a,b,c) ( memcpy((void *)a, (void *)b, (size_t)c))\r
+// bcopy is is a void function with the src/dest arguments reversed, being used in socket lib\r
+#define bcopy(a,b,c) ( memcpy((void *)b, (const void *)a, (size_t)c))\r
\r
// bcmp is same as memcmp, returns 0 for successful compare, non-zero otherwise\r
#define bcmp(a,b,c) ( memcmp((void *)a, (void *)b, (size_t)c))\r
\r
-//strsep is the same as strtok, the only difference is for strsep the 1st parameter is a char**\r
-#define strsep(a,b) (strtok(*a,b))\r
+/*\r
+ * Get next token from string *stringp, where tokens are possibly-empty\r
+ * strings separated by characters from delim.\r
+ *\r
+ * Writes NULs into the string at *stringp to end tokens.\r
+ * delim need not remain constant from call to call.\r
+ * On return, *stringp points past the last NUL written (if there might\r
+ * be further tokens), or is NULL (if there are definitely no more tokens).\r
+ *\r
+ * If *stringp is NULL, strsep returns NULL.\r
+ */\r
+char *\r
+strsep(\r
+ register char **stringp,\r
+ register const char *delim\r
+ );\r
\r
__END_DECLS\r
\r
projects / mirror_edk2.git / blobdiff