一)stddef.h
/* stddef.h: ANSI 'C' (X3J11 Oct 88) library header, section 4.1.4 */
/* Copyright (C) ARM Ltd., 1999
* All rights reserved
* RCS $Revision$
* Checkin $Date$
* Revising $Author: agrant $
*/
/* Copyright (C) Codemist Ltd., 1988 */
/* Copyright 1991 ARM Limited. All rights reserved. */
/* version 0.05 */
/*
* The following types and macros are defined in several headers referred to in
* the descriptions of the functions declared in that header. They are also
* defined in this header file.
*/
#ifndef __stddef_h
#define __stddef_h
#define __ARMCLIB_VERSION 5060037
#ifndef __STDDEF_DECLS
#define __STDDEF_DECLS
#undef __CLIBNS
#ifdef __cplusplus
namespace std {
#define __CLIBNS ::std::
extern "C" {
#else
#define __CLIBNS
#endif /* __cplusplus */
#if __sizeof_ptr == 8
typedef signed long ptrdiff_t;
#else
typedef signed int ptrdiff_t;
#endif
#if defined(__cplusplus) || !defined(__STRICT_ANSI__)
/* unconditional in C++ and non-strict C for consistency of debug info */
#if __sizeof_ptr == 8
typedef unsigned long size_t; /* see <stddef.h> */
#else
typedef unsigned int size_t; /* see <stddef.h> */
#endif
#elif !defined(__size_t)
#define __size_t 1
#if __sizeof_ptr == 8
typedef unsigned long size_t; /* see <stddef.h> */
#else
typedef unsigned int size_t; /* see <stddef.h> */
#endif
/* the unsigned integral type of the result of the sizeof operator. */
#endif
#ifndef __cplusplus /* wchar_t is a builtin type for C++ */
#if !defined(__STRICT_ANSI__)
/* unconditional in non-strict C for consistency of debug info */
#if defined(__WCHAR32) || (defined(__ARM_SIZEOF_WCHAR_T) && __ARM_SIZEOF_WCHAR_T == 4)
typedef unsigned int wchar_t; /* also in <stdlib.h> and <inttypes.h> */
#else
typedef unsigned short wchar_t; /* also in <stdlib.h> and <inttypes.h> */
#endif
#elif !defined(__wchar_t)
#define __wchar_t 1
#if defined(__WCHAR32) || (defined(__ARM_SIZEOF_WCHAR_T) && __ARM_SIZEOF_WCHAR_T == 4)
typedef unsigned int wchar_t; /* also in <stdlib.h> and <inttypes.h> */
#else
typedef unsigned short wchar_t; /* also in <stdlib.h> and <inttypes.h> */
#endif
/*
* An integral type whose range of values can represent distinct codes for
* all members of the largest extended character set specified among the
* supported locales; the null character shall have the code value zero and
* each member of the basic character set shall have a code value when used
* as the lone character in an integer character constant.
*/
#endif
#endif
#undef NULL /* others (e.g. <stdio.h>) also define */
#define NULL 0
/* null pointer constant. */
#ifdef __clang__
#define offsetof(t, d) __builtin_offsetof(t, d)
#else
/* EDG uses __INTADDR__ to avoid errors when strict */
#define offsetof(t, memb) ((__CLIBNS size_t)__INTADDR__(&(((t *)0)->memb)))
#endif
#if !defined(__STRICT_ANSI__) || (defined(__STDC_VERSION__) && 201112L <= __STDC_VERSION__) || (defined(__cplusplus) && 201103L <= __cplusplus)
typedef long double max_align_t;
#endif
#ifdef __cplusplus
} /* extern "C" */
} /* namespace std */
#endif /* __cplusplus */
#endif /* __STDDEF_DECLS */
#ifdef __cplusplus
#ifndef __STDDEF_NO_EXPORTS
using ::std::size_t;
using ::std::ptrdiff_t;
#if !defined(__STRICT_ANSI__) || (defined(__cplusplus) && 201103L <= __cplusplus)
using ::std::max_align_t;
#endif
#endif
#endif /* __cplusplus */
#endif
/* end of stddef.h */
二)stdint.h
/* Copyright (C) ARM Ltd., 1999,2014 */
/* All rights reserved */
/*
* RCS $Revision$
* Checkin $Date$
* Revising $Author: agrant $
*/
#ifndef __stdint_h
#define __stdint_h
#define __ARMCLIB_VERSION 5060037
#ifdef __INT64_TYPE__
/* armclang predefines '__INT64_TYPE__' and '__INT64_C_SUFFIX__' */
#define __INT64 __INT64_TYPE__
#else
/* armcc has builtin '__int64' which can be used in --strict mode */
#define __INT64 __int64
#define __INT64_C_SUFFIX__ ll
#endif
#define __PASTE2(x, y) x ## y
#define __PASTE(x, y) __PASTE2(x, y)
#define __INT64_C(x) __ESCAPE__(__PASTE(x, __INT64_C_SUFFIX__))
#define __UINT64_C(x) __ESCAPE__(__PASTE(x ## u, __INT64_C_SUFFIX__))
#if defined(__clang__) || (defined(__ARMCC_VERSION) && !defined(__STRICT_ANSI__))
/* armclang and non-strict armcc allow 'long long' in system headers */
#define __LONGLONG long long
#else
/* strict armcc has '__int64' */
#define __LONGLONG __int64
#endif
#ifndef __STDINT_DECLS
#define __STDINT_DECLS
#undef __CLIBNS
#ifdef __cplusplus
namespace std {
#define __CLIBNS std::
extern "C" {
#else
#define __CLIBNS
#endif /* __cplusplus */
/*
* 'signed' is redundant below, except for 'signed char' and if
* the typedef is used to declare a bitfield.
*/
/* 7.18.1.1 */
/* exact-width signed integer types */
typedef signed char int8_t;
typedef signed short int int16_t;
typedef signed int int32_t;
typedef signed __INT64 int64_t;
/* exact-width unsigned integer types */
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
typedef unsigned __INT64 uint64_t;
/* 7.18.1.2 */
/* smallest type of at least n bits */
/* minimum-width signed integer types */
typedef signed char int_least8_t;
typedef signed short int int_least16_t;
typedef signed int int_least32_t;
typedef signed __INT64 int_least64_t;
/* minimum-width unsigned integer types */
typedef unsigned char uint_least8_t;
typedef unsigned short int uint_least16_t;
typedef unsigned int uint_least32_t;
typedef unsigned __INT64 uint_least64_t;
/* 7.18.1.3 */
/* fastest minimum-width signed integer types */
typedef signed int int_fast8_t;
typedef signed int int_fast16_t;
typedef signed int int_fast32_t;
typedef signed __INT64 int_fast64_t;
/* fastest minimum-width unsigned integer types */
typedef unsigned int uint_fast8_t;
typedef unsigned int uint_fast16_t;
typedef unsigned int uint_fast32_t;
typedef unsigned __INT64 uint_fast64_t;
/* 7.18.1.4 integer types capable of holding object pointers */
#if __sizeof_ptr == 8
typedef signed __INT64 intptr_t;
typedef unsigned __INT64 uintptr_t;
#else
typedef signed int intptr_t;
typedef unsigned int uintptr_t;
#endif
/* 7.18.1.5 greatest-width integer types */
typedef signed __LONGLONG intmax_t;
typedef unsigned __LONGLONG uintmax_t;
#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS)
/* 7.18.2.1 */
/* minimum values of exact-width signed integer types */
#define INT8_MIN -128
#define INT16_MIN -32768
#define INT32_MIN (~0x7fffffff) /* -2147483648 is unsigned */
#define INT64_MIN __INT64_C(~0x7fffffffffffffff) /* -9223372036854775808 is unsigned */
/* maximum values of exact-width signed integer types */
#define INT8_MAX 127
#define INT16_MAX 32767
#define INT32_MAX 2147483647
#define INT64_MAX __INT64_C(9223372036854775807)
/* maximum values of exact-width unsigned integer types */
#define UINT8_MAX 255
#define UINT16_MAX 65535
#define UINT32_MAX 4294967295u
#define UINT64_MAX __UINT64_C(18446744073709551615)
/* 7.18.2.2 */
/* minimum values of minimum-width signed integer types */
#define INT_LEAST8_MIN -128
#define INT_LEAST16_MIN -32768
#define INT_LEAST32_MIN (~0x7fffffff)
#define INT_LEAST64_MIN __INT64_C(~0x7fffffffffffffff)
/* maximum values of minimum-width signed integer types */
#define INT_LEAST8_MAX 127
#define INT_LEAST16_MAX 32767
#define INT_LEAST32_MAX 2147483647
#define INT_LEAST64_MAX __INT64_C(9223372036854775807)
/* maximum values of minimum-width unsigned integer types */
#define UINT_LEAST8_MAX 255
#define UINT_LEAST16_MAX 65535
#define UINT_LEAST32_MAX 4294967295u
#define UINT_LEAST64_MAX __UINT64_C(18446744073709551615)
/* 7.18.2.3 */
/* minimum values of fastest minimum-width signed integer types */
#define INT_FAST8_MIN (~0x7fffffff)
#define INT_FAST16_MIN (~0x7fffffff)
#define INT_FAST32_MIN (~0x7fffffff)
#define INT_FAST64_MIN __INT64_C(~0x7fffffffffffffff)
/* maximum values of fastest minimum-width signed integer types */
#define INT_FAST8_MAX 2147483647
#define INT_FAST16_MAX 2147483647
#define INT_FAST32_MAX 2147483647
#define INT_FAST64_MAX __INT64_C(9223372036854775807)
/* maximum values of fastest minimum-width unsigned integer types */
#define UINT_FAST8_MAX 4294967295u
#define UINT_FAST16_MAX 4294967295u
#define UINT_FAST32_MAX 4294967295u
#define UINT_FAST64_MAX __UINT64_C(18446744073709551615)
/* 7.18.2.4 */
/* minimum value of pointer-holding signed integer type */
#if __sizeof_ptr == 8
#define INTPTR_MIN INT64_MIN
#else
#define INTPTR_MIN INT32_MIN
#endif
/* maximum value of pointer-holding signed integer type */
#if __sizeof_ptr == 8
#define INTPTR_MAX INT64_MAX
#else
#define INTPTR_MAX INT32_MAX
#endif
/* maximum value of pointer-holding unsigned integer type */
#if __sizeof_ptr == 8
#define UINTPTR_MAX UINT64_MAX
#else
#define UINTPTR_MAX UINT32_MAX
#endif
/* 7.18.2.5 */
/* minimum value of greatest-width signed integer type */
#define INTMAX_MIN __ESCAPE__(~0x7fffffffffffffffll)
/* maximum value of greatest-width signed integer type */
#define INTMAX_MAX __ESCAPE__(9223372036854775807ll)
/* maximum value of greatest-width unsigned integer type */
#define UINTMAX_MAX __ESCAPE__(18446744073709551615ull)
/* 7.18.3 */
/* limits of ptrdiff_t */
#if __sizeof_ptr == 8
#define PTRDIFF_MIN INT64_MIN
#define PTRDIFF_MAX INT64_MAX
#else
#define PTRDIFF_MIN INT32_MIN
#define PTRDIFF_MAX INT32_MAX
#endif
/* limits of sig_atomic_t */
#define SIG_ATOMIC_MIN (~0x7fffffff)
#define SIG_ATOMIC_MAX 2147483647
/* limit of size_t */
#if __sizeof_ptr == 8
#define SIZE_MAX UINT64_MAX
#else
#define SIZE_MAX UINT32_MAX
#endif
/* limits of wchar_t */
/* NB we have to undef and redef because they're defined in both
* stdint.h and wchar.h */
#undef WCHAR_MIN
#undef WCHAR_MAX
#if defined(__WCHAR32) || (defined(__ARM_SIZEOF_WCHAR_T) && __ARM_SIZEOF_WCHAR_T == 4)
#define WCHAR_MIN 0
#define WCHAR_MAX 0xffffffffU
#else
#define WCHAR_MIN 0
#define WCHAR_MAX 65535
#endif
/* limits of wint_t */
#define WINT_MIN (~0x7fffffff)
#define WINT_MAX 2147483647
#endif /* __STDC_LIMIT_MACROS */
#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS)
/* 7.18.4.1 macros for minimum-width integer constants */
#define INT8_C(x) (x)
#define INT16_C(x) (x)
#define INT32_C(x) (x)
#define INT64_C(x) __INT64_C(x)
#define UINT8_C(x) (x ## u)
#define UINT16_C(x) (x ## u)
#define UINT32_C(x) (x ## u)
#define UINT64_C(x) __UINT64_C(x)
/* 7.18.4.2 macros for greatest-width integer constants */
#define INTMAX_C(x) __ESCAPE__(x ## ll)
#define UINTMAX_C(x) __ESCAPE__(x ## ull)
#endif /* __STDC_CONSTANT_MACROS */
#ifdef __cplusplus
} /* extern "C" */
} /* namespace std */
#endif /* __cplusplus */
#endif /* __STDINT_DECLS */
#ifdef __cplusplus
#ifndef __STDINT_NO_EXPORTS
using ::std::int8_t;
using ::std::int16_t;
using ::std::int32_t;
using ::std::int64_t;
using ::std::uint8_t;
using ::std::uint16_t;
using ::std::uint32_t;
using ::std::uint64_t;
using ::std::int_least8_t;
using ::std::int_least16_t;
using ::std::int_least32_t;
using ::std::int_least64_t;
using ::std::uint_least8_t;
using ::std::uint_least16_t;
using ::std::uint_least32_t;
using ::std::uint_least64_t;
using ::std::int_fast8_t;
using ::std::int_fast16_t;
using ::std::int_fast32_t;
using ::std::int_fast64_t;
using ::std::uint_fast8_t;
using ::std::uint_fast16_t;
using ::std::uint_fast32_t;
using ::std::uint_fast64_t;
using ::std::intptr_t;
using ::std::uintptr_t;
using ::std::intmax_t;
using ::std::uintmax_t;
#endif
#endif /* __cplusplus */
#undef __INT64
#undef __LONGLONG
#endif /* __stdint_h */
/* end of stdint.h */
三)string.h
/* string.h: ANSI 'C' (X3J11 Oct 88) library header, section 4.11 */
/* Copyright (C) Codemist Ltd., 1988-1993. */
/* Copyright 1991-1993 ARM Limited. All rights reserved. */
/* version 0.04 */
/*
* RCS $Revision$
* Checkin $Date$
*/
/*
* 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
#define __ARMCLIB_VERSION 5060037
#define _ARMABI __declspec(__nothrow)
#ifndef __STRING_DECLS
#define __STRING_DECLS
#undef __CLIBNS
#ifdef __cplusplus
namespace std {
#define __CLIBNS std::
extern "C" {
#else
#define __CLIBNS
#endif /* __cplusplus */
#if defined(__cplusplus) || !defined(__STRICT_ANSI__)
/* unconditional in C++ and non-strict C for consistency of debug info */
#if __sizeof_ptr == 8
typedef unsigned long size_t; /* see <stddef.h> */
#else
typedef unsigned int size_t; /* see <stddef.h> */
#endif
#elif !defined(__size_t)
#define __size_t 1
#if __sizeof_ptr == 8
typedef unsigned long size_t; /* see <stddef.h> */
#else
typedef unsigned int size_t; /* see <stddef.h> */
#endif
#endif
#undef NULL
#define NULL 0 /* see <stddef.h> */
extern _ARMABI void *memcpy(void * __restrict /*s1*/,
const void * __restrict /*s2*/, size_t /*n*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
extern _ARMABI void *memmove(void * /*s1*/,
const void * /*s2*/, size_t /*n*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
extern _ARMABI char *strcpy(char * __restrict /*s1*/, const char * __restrict /*s2*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
extern _ARMABI char *strncpy(char * __restrict /*s1*/, const char * __restrict /*s2*/, size_t /*n*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
extern _ARMABI char *strcat(char * __restrict /*s1*/, const char * __restrict /*s2*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
extern _ARMABI char *strncat(char * __restrict /*s1*/, const char * __restrict /*s2*/, size_t /*n*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
extern _ARMABI int memcmp(const void * /*s1*/, const void * /*s2*/, size_t /*n*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
extern _ARMABI int strcmp(const char * /*s1*/, const char * /*s2*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
extern _ARMABI int strncmp(const char * /*s1*/, const char * /*s2*/, size_t /*n*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
extern _ARMABI int strcasecmp(const char * /*s1*/, const char * /*s2*/) __attribute__((__nonnull__(1,2)));
/*
* compares the string pointed to by s1 to the string pointed to by s2,
* case-insensitively as defined by 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.
*/
extern _ARMABI int strncasecmp(const char * /*s1*/, const char * /*s2*/, size_t /*n*/) __attribute__((__nonnull__(1,2)));
/*
* 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, case-insensitively as defined by 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.
*/
extern _ARMABI int strcoll(const char * /*s1*/, const char * /*s2*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
extern _ARMABI size_t strxfrm(char * __restrict /*s1*/, const char * __restrict /*s2*/, size_t /*n*/) __attribute__((__nonnull__(2)));
/*
* 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.
*/
#ifdef __cplusplus
extern _ARMABI const void *memchr(const void * /*s*/, int /*c*/, size_t /*n*/) __attribute__((__nonnull__(1)));
extern "C++" void *memchr(void * __s, int __c, size_t __n) __attribute__((__nonnull__(1)));
extern "C++" inline void *memchr(void * __s, int __c, size_t __n)
{ return const_cast<void *>(memchr(const_cast<const void *>(__s), __c, __n)); }
#else
extern _ARMABI void *memchr(const void * /*s*/, int /*c*/, size_t /*n*/) __attribute__((__nonnull__(1)));
#endif
/*
* 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.
*/
#ifdef __cplusplus
extern _ARMABI const char *strchr(const char * /*s*/, int /*c*/) __attribute__((__nonnull__(1)));
extern "C++" char *strchr(char * __s, int __c) __attribute__((__nonnull__(1)));
extern "C++" inline char *strchr(char * __s, int __c)
{ return const_cast<char *>(strchr(const_cast<const char *>(__s), __c)); }
#else
extern _ARMABI char *strchr(const char * /*s*/, int /*c*/) __attribute__((__nonnull__(1)));
#endif
/*
* 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.
*/
extern _ARMABI size_t strcspn(const char * /*s1*/, const char * /*s2*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
#ifdef __cplusplus
extern _ARMABI const char *strpbrk(const char * /*s1*/, const char * /*s2*/) __attribute__((__nonnull__(1,2)));
extern "C++" char *strpbrk(char * __s1, const char * __s2) __attribute__((__nonnull__(1,2)));
extern "C++" inline char *strpbrk(char * __s1, const char * __s2)
{ return const_cast<char *>(strpbrk(const_cast<const char *>(__s1), __s2)); }
#else
extern _ARMABI char *strpbrk(const char * /*s1*/, const char * /*s2*/) __attribute__((__nonnull__(1,2)));
#endif
/*
* 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.
*/
#ifdef __cplusplus
extern _ARMABI const char *strrchr(const char * /*s*/, int /*c*/) __attribute__((__nonnull__(1)));
extern "C++" char *strrchr(char * __s, int __c) __attribute__((__nonnull__(1)));
extern "C++" inline char *strrchr(char * __s, int __c)
{ return const_cast<char *>(strrchr(const_cast<const char *>(__s), __c)); }
#else
extern _ARMABI char *strrchr(const char * /*s*/, int /*c*/) __attribute__((__nonnull__(1)));
#endif
/*
* 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.
*/
extern _ARMABI size_t strspn(const char * /*s1*/, const char * /*s2*/) __attribute__((__nonnull__(1,2)));
/*
* 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.
*/
#ifdef __cplusplus
extern _ARMABI const char *strstr(const char * /*s1*/, const char * /*s2*/) __attribute__((__nonnull__(1,2)));
extern "C++" char *strstr(char * __s1, const char * __s2) __attribute__((__nonnull__(1,2)));
extern "C++" inline char *strstr(char * __s1, const char * __s2)
{ return const_cast<char *>(strstr(const_cast<const char *>(__s1), __s2)); }
#else
extern _ARMABI char *strstr(const char * /*s1*/, const char * /*s2*/) __attribute__((__nonnull__(1,2)));
#endif
/*
* 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.
*/
extern _ARMABI char *strtok(char * __restrict /*s1*/, const char * __restrict /*s2*/) __attribute__((__nonnull__(2)));
extern _ARMABI char *_strtok_r(char * /*s1*/, const char * /*s2*/, char ** /*ptr*/) __attribute__((__nonnull__(2,3)));
#ifndef __STRICT_ANSI__
extern _ARMABI char *strtok_r(char * /*s1*/, const char * /*s2*/, char ** /*ptr*/) __attribute__((__nonnull__(2,3)));
#endif
/*
* 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.
*
* strtok_r() is a common extension which works exactly like
* strtok(), but instead of storing its state in a hidden
* library variable, requires the user to pass in a pointer to a
* char * variable which will be used instead. Any sequence of
* calls to strtok_r() passing the same char ** pointer should
* behave exactly like the corresponding sequence of calls to
* strtok(). This means that strtok_r() can safely be used in
* multi-threaded programs, and also that you can tokenise two
* strings in parallel.
*/
extern _ARMABI void *memset(void * /*s*/, int /*c*/, size_t /*n*/) __attribute__((__nonnull__(1)));
/*
* copies the value of c (converted to an unsigned char) into each of the
* first n charactes of the object pointed to by s.
* Returns: the value of s.
*/
extern _ARMABI 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. The array pointed to shall not be
* modified by the program, but may be overwritten by a
* subsequent call to the strerror function.
*/
extern _ARMABI size_t strlen(const char * /*s*/) __attribute__((__nonnull__(1)));
/*
* computes the length of the string pointed to by s.
* Returns: the number of characters that precede the terminating null
* character.
*/
extern _ARMABI size_t strlcpy(char * /*dst*/, const char * /*src*/, size_t /*len*/) __attribute__((__nonnull__(1,2)));
/*
* copies the string src into the string dst, using no more than
* len bytes of dst. Always null-terminates dst _within the
* length len (i.e. will copy at most len-1 bytes of string plus
* a NUL), unless len is actually zero.
*
* Return value is the length of the string that _would_ have
* been written, i.e. the length of src. Thus, the operation
* succeeded without truncation if and only if ret < len;
* otherwise, the value in ret tells you how big to make dst if
* you decide to reallocate it. (That value does _not_ include
* the NUL.)
*
* This is a BSD-derived library extension, which we are
* permitted to declare in a standard header because ISO defines
* function names beginning with 'str' as reserved for future
* expansion of <string.h>.
*/
extern _ARMABI size_t strlcat(char * /*dst*/, const char * /*src*/, size_t /*len*/) __attribute__((__nonnull__(1,2)));
/*
* concatenates the string src to the string dst, using no more
* than len bytes of dst. Always null-terminates dst _within the
* length len (i.e. will copy at most len-1 bytes of string plus
* a NUL), unless len is actually zero.
*
* Return value is the length of the string that _would_ have
* been written, i.e. the length of src plus the original length
* of dst. Thus, the operation succeeded without truncation if
* and only if ret < len; otherwise, the value in ret tells you
* how big to make dst if you decide to reallocate it. (That
* value does _not_ include the NUL.)
*
* If no NUL is encountered within the first len bytes of dst,
* then the length of dst is considered to have been equal to
* len for the purposes of the return value (as if there were a
* NUL at dst[len]). Thus, the return value in this case is len
* + strlen(src).
*
* This is a BSD-derived library extension, which we are
* permitted to declare in a standard header because ISO defines
* function names beginning with 'str' as reserved for future
* expansion of <string.h>.
*/
extern _ARMABI void _membitcpybl(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
extern _ARMABI void _membitcpybb(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
extern _ARMABI void _membitcpyhl(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
extern _ARMABI void _membitcpyhb(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
extern _ARMABI void _membitcpywl(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
extern _ARMABI void _membitcpywb(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
extern _ARMABI void _membitmovebl(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
extern _ARMABI void _membitmovebb(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
extern _ARMABI void _membitmovehl(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
extern _ARMABI void _membitmovehb(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
extern _ARMABI void _membitmovewl(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
extern _ARMABI void _membitmovewb(void * /*dest*/, const void * /*src*/, int /*destoffset*/, int /*srcoffset*/, size_t /*nbits*/) __attribute__((__nonnull__(1,2)));
/*
* Copies or moves a piece of memory from one place to another,
* with one-bit granularity. So you can start or finish a copy
* part way through a byte, and you can copy between regions
* with different alignment within a byte.
*
* All these functions have the same prototype: two void *
* pointers for destination and source, then two integers
* giving the bit offset from those pointers, and finally the
* number of bits to copy.
*
* Just like memcpy and memmove, the "cpy" functions copy as
* fast as they can in the assumption that the memory regions
* do not overlap, while the "move" functions cope correctly
* with overlap.
*
* Treating memory as a stream of individual bits requires
* defining a convention about what order those bits are
* considered to be arranged in. The above functions support
* multiple conventions:
*
* - the "bl" functions consider the unit of memory to be the
* byte, and consider the bits within each byte to be
* arranged in little-endian fashion, so that the LSB comes
* first. (For example, membitcpybl(a,b,0,7,1) would copy
* the MSB of the byte at b to the LSB of the byte at a.)
*
* - the "bb" functions consider the unit of memory to be the
* byte, and consider the bits within each byte to be
* arranged in big-endian fashion, so that the MSB comes
* first.
*
* - the "hl" functions consider the unit of memory to be the
* 16-bit halfword, and consider the bits within each word
* to be arranged in little-endian fashion.
*
* - the "hb" functions consider the unit of memory to be the
* 16-bit halfword, and consider the bits within each word
* to be arranged in big-endian fashion.
*
* - the "wl" functions consider the unit of memory to be the
* 32-bit word, and consider the bits within each word to be
* arranged in little-endian fashion.
*
* - the "wb" functions consider the unit of memory to be the
* 32-bit word, and consider the bits within each word to be
* arranged in big-endian fashion.
*/
#ifdef __cplusplus
} /* extern "C" */
} /* namespace std */
#endif /* __cplusplus */
#endif /* __STRING_DECLS */
#ifdef __cplusplus
#ifndef __STRING_NO_EXPORTS
using ::std::size_t;
using ::std::memcpy;
using ::std::memmove;
using ::std::strcpy;
using ::std::strncpy;
using ::std::strcat;
using ::std::strncat;
using ::std::memcmp;
using ::std::strcmp;
using ::std::strncmp;
using ::std::strcasecmp;
using ::std::strncasecmp;
using ::std::strcoll;
using ::std::strxfrm;
using ::std::memchr;
using ::std::strchr;
using ::std::strcspn;
using ::std::strpbrk;
using ::std::strrchr;
using ::std::strspn;
using ::std::strstr;
using ::std::strtok;
#ifndef __STRICT_ANSI__
using ::std::strtok_r;
#endif
using ::std::_strtok_r;
using ::std::memset;
using ::std::strerror;
using ::std::strlen;
using ::std::strlcpy;
using ::std::strlcat;
using ::std::_membitcpybl;
using ::std::_membitcpybb;
using ::std::_membitcpyhl;
using ::std::_membitcpyhb;
using ::std::_membitcpywl;
using ::std::_membitcpywb;
using ::std::_membitmovebl;
using ::std::_membitmovebb;
using ::std::_membitmovehl;
using ::std::_membitmovehb;
using ::std::_membitmovewl;
using ::std::_membitmovewb;
#endif /* __STRING_NO_EXPORTS */
#endif /* __cplusplus */
#endif
/* end of string.h */