string.h (51072bd6bf79ef2bc6a922079bff57c31c1effbc) string.h (854023f054291b7ecebb98ce5d91701caf244713)
1// -*- C++ -*-
2//===--------------------------- string.h ---------------------------------===//
3//
4// The LLVM Compiler Infrastructure
5//
6// This file is distributed under the University of Illinois Open Source
7// License. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
1/*-
2 * Copyright (c) 1990, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * @(#)string.h 8.1 (Berkeley) 6/2/93
30 * $FreeBSD$
31 */
10
32
11#ifndef _LIBCPP_STRING_H
12#define _LIBCPP_STRING_H
33#ifndef _STRING_H_
34#define _STRING_H_
13
35
36#include <sys/cdefs.h>
37#include <sys/_null.h>
38#include <sys/_types.h>
39
14/*
40/*
15 string.h synopsis
41 * Prototype functions which were historically defined in <string.h>, but
42 * are required by POSIX to be prototyped in <strings.h>.
43 */
44#if __BSD_VISIBLE
45#include <strings.h>
46#endif
16
47
17Macros:
18
19 NULL
20
21Types:
22
23 size_t
24
25void* memcpy(void* restrict s1, const void* restrict s2, size_t n);
26void* memmove(void* s1, const void* s2, size_t n);
27char* strcpy (char* restrict s1, const char* restrict s2);
28char* strncpy(char* restrict s1, const char* restrict s2, size_t n);
29char* strcat (char* restrict s1, const char* restrict s2);
30char* strncat(char* restrict s1, const char* restrict s2, size_t n);
31int memcmp(const void* s1, const void* s2, size_t n);
32int strcmp (const char* s1, const char* s2);
33int strncmp(const char* s1, const char* s2, size_t n);
34int strcoll(const char* s1, const char* s2);
35size_t strxfrm(char* restrict s1, const char* restrict s2, size_t n);
36const void* memchr(const void* s, int c, size_t n);
37 void* memchr( void* s, int c, size_t n);
38const char* strchr(const char* s, int c);
39 char* strchr( char* s, int c);
40size_t strcspn(const char* s1, const char* s2);
41const char* strpbrk(const char* s1, const char* s2);
42 char* strpbrk( char* s1, const char* s2);
43const char* strrchr(const char* s, int c);
44 char* strrchr( char* s, int c);
45size_t strspn(const char* s1, const char* s2);
46const char* strstr(const char* s1, const char* s2);
47 char* strstr( char* s1, const char* s2);
48char* strtok(char* restrict s1, const char* restrict s2);
49void* memset(void* s, int c, size_t n);
50char* strerror(int errnum);
51size_t strlen(const char* s);
52
53*/
54
55#include <__config>
56
57#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
58#pragma GCC system_header
48#ifndef _SIZE_T_DECLARED
49typedef __size_t size_t;
50#define _SIZE_T_DECLARED
59#endif
60
51#endif
52
61#include_next <string.h>
62
63// MSVCRT, GNU libc and its derivates may already have the correct prototype in
64// <string.h>. This macro can be defined by users if their C library provides
65// the right signature.
66#if defined(__CORRECT_ISO_CPP_STRING_H_PROTO) || defined(_LIBCPP_MSVCRT) || \
67 defined(__sun__) || defined(_STRING_H_CPLUSPLUS_98_CONFORMANCE_)
68#define _LIBCPP_STRING_H_HAS_CONST_OVERLOADS
53__BEGIN_DECLS
54#if __XSI_VISIBLE >= 600
55void *memccpy(void * __restrict, const void * __restrict, int, size_t);
69#endif
56#endif
57void *memchr(const void *, int, size_t) __pure;
58#if __BSD_VISIBLE
59void *memrchr(const void *, int, size_t) __pure;
60#endif
61int memcmp(const void *, const void *, size_t) __pure;
62void *memcpy(void * __restrict, const void * __restrict, size_t);
63#if __BSD_VISIBLE
64void *memmem(const void *, size_t, const void *, size_t) __pure;
65#endif
66void *memmove(void *, const void *, size_t);
67void *memset(void *, int, size_t);
68#if __POSIX_VISIBLE >= 200809
69char *stpcpy(char * __restrict, const char * __restrict);
70char *stpncpy(char * __restrict, const char * __restrict, size_t);
71#endif
72#if __BSD_VISIBLE
73char *strcasestr(const char *, const char *) __pure;
74#endif
75char *strcat(char * __restrict, const char * __restrict);
76char *strchr(const char *, int) __pure;
77#if __BSD_VISIBLE
78char *strchrnul(const char*, int) __pure;
79#endif
80int strcmp(const char *, const char *) __pure;
81int strcoll(const char *, const char *);
82char *strcpy(char * __restrict, const char * __restrict);
83size_t strcspn(const char *, const char *) __pure;
84#if __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE
85char *strdup(const char *) __malloc_like;
86#endif
87char *strerror(int);
88#if __POSIX_VISIBLE >= 200112
89int strerror_r(int, char *, size_t);
90#endif
91#if __BSD_VISIBLE
92size_t strlcat(char * __restrict, const char * __restrict, size_t);
93size_t strlcpy(char * __restrict, const char * __restrict, size_t);
94#endif
95size_t strlen(const char *) __pure;
96#if __BSD_VISIBLE
97void strmode(int, char *);
98#endif
99char *strncat(char * __restrict, const char * __restrict, size_t);
100int strncmp(const char *, const char *, size_t) __pure;
101char *strncpy(char * __restrict, const char * __restrict, size_t);
102#if __POSIX_VISIBLE >= 200809
103char *strndup(const char *, size_t) __malloc_like;
104size_t strnlen(const char *, size_t) __pure;
105#endif
106#if __BSD_VISIBLE
107char *strnstr(const char *, const char *, size_t) __pure;
108#endif
109char *strpbrk(const char *, const char *) __pure;
110char *strrchr(const char *, int) __pure;
111#if __BSD_VISIBLE
112char *strsep(char **, const char *);
113#endif
114#if __POSIX_VISIBLE >= 200809
115char *strsignal(int);
116#endif
117size_t strspn(const char *, const char *) __pure;
118char *strstr(const char *, const char *) __pure;
119char *strtok(char * __restrict, const char * __restrict);
120#if __POSIX_VISIBLE >= 199506 || __XSI_VISIBLE >= 500
121char *strtok_r(char *, const char *, char **);
122#endif
123size_t strxfrm(char * __restrict, const char * __restrict, size_t);
124#if __BSD_VISIBLE
70
125
71#if defined(__cplusplus) && !defined(_LIBCPP_STRING_H_HAS_CONST_OVERLOADS) && defined(_LIBCPP_PREFERRED_OVERLOAD)
72extern "C++" {
73inline _LIBCPP_INLINE_VISIBILITY
74char* __libcpp_strchr(const char* __s, int __c) {return (char*)strchr(__s, __c);}
75inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
76const char* strchr(const char* __s, int __c) {return __libcpp_strchr(__s, __c);}
77inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
78 char* strchr( char* __s, int __c) {return __libcpp_strchr(__s, __c);}
126#ifndef _SWAB_DECLARED
127#define _SWAB_DECLARED
79
128
80inline _LIBCPP_INLINE_VISIBILITY
81char* __libcpp_strpbrk(const char* __s1, const char* __s2) {return (char*)strpbrk(__s1, __s2);}
82inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
83const char* strpbrk(const char* __s1, const char* __s2) {return __libcpp_strpbrk(__s1, __s2);}
84inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
85 char* strpbrk( char* __s1, const char* __s2) {return __libcpp_strpbrk(__s1, __s2);}
129#ifndef _SSIZE_T_DECLARED
130typedef __ssize_t ssize_t;
131#define _SSIZE_T_DECLARED
132#endif /* _SIZE_T_DECLARED */
86
133
87inline _LIBCPP_INLINE_VISIBILITY
88char* __libcpp_strrchr(const char* __s, int __c) {return (char*)strrchr(__s, __c);}
89inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
90const char* strrchr(const char* __s, int __c) {return __libcpp_strrchr(__s, __c);}
91inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
92 char* strrchr( char* __s, int __c) {return __libcpp_strrchr(__s, __c);}
134void swab(const void * __restrict, void * __restrict, ssize_t);
135#endif /* _SWAB_DECLARED */
93
136
94inline _LIBCPP_INLINE_VISIBILITY
95void* __libcpp_memchr(const void* __s, int __c, size_t __n) {return (void*)memchr(__s, __c, __n);}
96inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
97const void* memchr(const void* __s, int __c, size_t __n) {return __libcpp_memchr(__s, __c, __n);}
98inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
99 void* memchr( void* __s, int __c, size_t __n) {return __libcpp_memchr(__s, __c, __n);}
137int timingsafe_bcmp(const void *, const void *, size_t);
138int timingsafe_memcmp(const void *, const void *, size_t);
139#endif /* __BSD_VISIBLE */
100
140
101inline _LIBCPP_INLINE_VISIBILITY
102char* __libcpp_strstr(const char* __s1, const char* __s2) {return (char*)strstr(__s1, __s2);}
103inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
104const char* strstr(const char* __s1, const char* __s2) {return __libcpp_strstr(__s1, __s2);}
105inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
106 char* strstr( char* __s1, const char* __s2) {return __libcpp_strstr(__s1, __s2);}
107}
141#if __POSIX_VISIBLE >= 200809 || defined(_XLOCALE_H_)
142#include <xlocale/_string.h>
108#endif
143#endif
144__END_DECLS
109
145
110#endif // _LIBCPP_STRING_H
146#endif /* _STRING_H_ */