/* Copyright 1996 Acorn Computers Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma force_top_level
#pragma include_only_once
/* string.h: ISO 'C' (9899:1999) library header, section 7.21 */
/* Copyright (C) Codemist Ltd. */
/* Copyright (C) Acorn Computers Ltd. 1991, 1992 */
/* version 2.01 */
/*
* string.h declares one type and several functions, and defines one macro
* useful for manipulating character arrays and other objects treated as
* character arrays. Various methods are used for determining the lengths of
* the arrays, but in all cases a char * or void * argument points to the
* initial (lowest addresses) character of the array. If an array is written
* beyond the end of an object, the behaviour is undefined.
*/
#ifndef __string_h
#define __string_h
#ifndef __size_t
#define __size_t 1
typedef unsigned int size_t; /* from <stddef.h> */
#endif
#ifndef NULL
# define NULL 0
#endif
#ifdef __cplusplus
#define restrict
extern "C" {
#else
#define restrict __restrict
#endif
char *strcpy(char * restrict /*s1*/, const char * restrict /*s2*/);
/*
* copies the string pointed to by s2 (including the terminating nul
* character) into the array pointed to by s1. If copying takes place
* between objects that overlap, the behaviour is undefined.
* Returns: the value of s1.
*/
char *strncpy(char * restrict /*s1*/, const char * restrict /*s2*/,
size_t /*n*/);
/*
* copies not more than n characters (characters that follow a null
* character are not copied) from the array pointed to by s2 into the array
* pointed to by s1. If copying takes place between objects that overlap,
* the behaviour is undefined.
* Returns: the value of s1.
*/
char *strcat(char * restrict /*s1*/, const char * restrict /*s2*/);
/*
* appends a copy of the string pointed to by s2 (including the terminating
* null character) to the end of the string pointed to by s1. The initial
* character of s2 overwrites the null character at the end of s1.
* Returns: the value of s1.
*/
char *strncat(char * restrict /*s1*/, const char * restrict /*s2*/,
size_t /*n*/);
/*
* appends not more than n characters (a null character and characters that
* follow it are not appended) from the array pointed to by s2 to the end of
* the string pointed to by s1. The initial character of s2 overwrites the
* null character at the end of s1. A terminating null character is always
* appended to the result.
* Returns: the value of s1.
*/
/*
* The sign of a nonzero value returned by the comparison functions is
* determined by the sign of the difference between the values of the first
* pair of characters (both interpreted as unsigned char) that differ in the
* objects being compared.
*/
int memcmp(const void * /*s1*/, const void * /*s2*/, size_t /*n*/);
/*
* compares the first n characters of the object pointed to by s1 to the
* first n characters of the object pointed to by s2.
* Returns: an integer greater than, equal to, or less than zero, according
* as the object pointed to by s1 is greater than, equal to, or
* less than the object pointed to by s2.
*/
int strcmp(const char * /*s1*/, const char * /*s2*/);
/*
* compares the string pointed to by s1 to the string pointed to by s2.
* Returns: an integer greater than, equal to, or less than zero, according
* as the string pointed to by s1 is greater than, equal to, or
* less than the string pointed to by s2.
*/
int strncmp(const char * /*s1*/, const char * /*s2*/, size_t /*n*/);
/*
* compares not more than n characters (characters that follow a null
* character are not compared) from the array pointed to by s1 to the array
* pointed to by s2.
* Returns: an integer greater than, equal to, or less than zero, according
* as the string pointed to by s1 is greater than, equal to, or
* less than the string pointed to by s2.
*/
int strcoll(const char * /*s1*/, const char * /*s2*/);
/*
* compares the string pointed to by s1 to the string pointed to by s2, both
* interpreted as appropriate to the LC_COLLATE category of the current
* locale.
* Returns: an integer greater than, equal to, or less than zero, according
* as the string pointed to by s1 is greater than, equal to, or
* less than the string pointed to by s2 when both are interpreted
* as appropriate to the current locale.
*/
size_t strxfrm(char * restrict /*s1*/, const char * restrict /*s2*/,
size_t /*n*/);
/*
* transforms the string pointed to by s2 and places the resulting string
* into the array pointed to by s1. The transformation function is such that
* if the strcmp function 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 array pointed to
* by 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 behaviour is undefined.
* Returns: The length of the transformed string is returned (not including
* the terminating null character). If the value returned is n or
* more, the contents of the array pointed to by s1 are
* indeterminate.
*/
char *strchr(const char * /*s*/, int /*c*/);
/*
* locates the first occurence of c (converted to an char) in the string
* pointed to by s (including the terminating null character).
* Returns: a pointer to the located character, or a null pointer if the
* character does not occur in the string.
*/
size_t strcspn(const char * /*s1*/, const char * /*s2*/);
/*
* computes the length of the initial segment of the string pointed to by s1
* which consists entirely of characters not from the string pointed to by
* s2. The terminating null character is not considered part of s2.
* Returns: the length of the segment.
*/
char *strpbrk(const char * /*s1*/, const char * /*s2*/);
/*
* locates the first occurence in the string pointed to by s1 of any
* character from the string pointed to by s2.
* Returns: returns a pointer to the character, or a null pointer if no
* character form s2 occurs in s1.
*/
char *strrchr(const char * /*s*/, int /*c*/);
/*
* locates the last occurence of c (converted to a char) in the string
* pointed to by s. The terminating null character is considered part of
* the string.
* Returns: returns a pointer to the character, or a null pointer if c does
* not occur in the string.
*/
size_t strspn(const char * /*s1*/, const char * /*s2*/);
/*
* computes the length of the initial segment of the string pointed to by s1
* which consists entirely of characters from the string pointed to by S2
* Returns: the length of the segment.
*/
char *strstr(const char * /*s1*/, const char * /*s2*/);
/*
* locates the first occurence in the string pointed to by s1 of the
* sequence of characters (excluding the terminating null character) in the
* string pointed to by s2.
* Returns: a pointer to the located string, or a null pointer if the string
* is not found.
*/
char *strtok(char * restrict /*s1*/, const char * restrict /*s2*/);
/*
* A sequence of calls to the strtok function breaks the string pointed to
* by s1 into a sequence of tokens, each of which is delimited by a
* character from the string pointed to by s2. The first call in the
* sequence has s1 as its first argument, and is followed by calls with a
* null pointer as their first argument. The separator string pointed to by
* s2 may be different from call to call.
* The first call in the sequence searches for the first character that is
* not contained in the current separator string s2. If no such character
* is found, then there are no tokens in s1 and the strtok function returns
* a null pointer. If such a character is found, it is the start of the
* first token.
* The strtok function then searches from there for a character that is
* contained in the current separator string. If no such character is found,
* the current token extends to the end of the string pointed to by s1, and
* subsequent searches for a token will fail. If such a character is found,
* it is overwritten by a null character, which terminates the current
* token. The strtok function saves a pointer to the following character,
* from which the next search for a token will start.
* Each subsequent call, with a null pointer as the value for the first
* argument, starts searching from the saved pointer and behaves as
* described above.
* Returns: pointer to the first character of a token, or a null pointer if
* there is no token.
*/
void *memcpy(void * restrict /*s1*/, const void * restrict /*s2*/,
size_t /*n*/);
/*
* copies n characters from the object pointed to by s2 into the object
* pointed to by s1. If copying takes place between objects that overlap,
* the behaviour is undefined.
* Returns: the value of s1.
*/
void *memmove(void * /*s1*/, const void * /*s2*/, size_t /*n*/);
/*
* copies n characters from the object pointed to by s2 into the object
* pointed to by s1. Copying takes place as if the n characters from the
* object pointed to by s2 are first copied into a temporary array of n
* characters that does not overlap the objects pointed to by s1 and s2,
* and then the n characters from the temporary array are copied into the
* object pointed to by s1.
* Returns: the value of s1.
*/
void *memchr(const void * /*s*/, int /*c*/, size_t /*n*/);
/*
* locates the first occurence of c (converted to an unsigned char) in the
* initial n characters (each interpreted as unsigned char) of the object
* pointed to by s.
* Returns: a pointer to the located character, or a null pointer if the
* character does not occur in the object.
*/
void *memset(void * /*s*/, int /*c*/, size_t /*n*/);
/*
* copies the value of c (converted to an unsigned char) into each of the
* first n characters of the object pointed to by s.
* Returns: the value of s.
*/
char *strerror(int /*errnum*/);
/*
* maps the error number in errnum to an error message string.
* Returns: a pointer to the string, the contents of which are
* implementation-defined (under RISC OS the strings
* for the given errnums are as follows
* 0 "No error (errno = 0)"
* EDOM "EDOM - function argument out of range"
* ERANGE "ERANGE - function result not representable"
* ESIGNUM "ESIGNUM - illegal signal number to signal() or raise()"
* EILSEQ "EILSEQ - character encoding error"
* EOVERFLOW "EOVERFLOW - too large for data structure"
* EFBIG "EFBIG - data written to file lost due to exceeding
* file size limit"
* -1 Error message from _kernel_lastoserror(), if any,
* else "unspecified error"
* others "unknown error"
* ). The array pointed to shall not be
* modified by the program, but may be overwritten by a subsequent
* call to the strerror function.
*/
size_t strlen(const char * /*s*/);
/*
* computes the length of the string pointed to by s.
* Returns: the number of characters that precede the terminating null
* character.
*/
#ifdef __cplusplus
}
#endif
#undef restrict
#endif
/* end of string.h */