OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [uClibc/] [include/] [string.h] - Blame information for rev 1771

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1325 phoenix
/* Copyright (C) 1991-1993, 1995-2002, 2003 Free Software Foundation, Inc.
2
   This file is part of the GNU C Library.
3
 
4
   The GNU C Library is free software; you can redistribute it and/or
5
   modify it under the terms of the GNU Lesser General Public
6
   License as published by the Free Software Foundation; either
7
   version 2.1 of the License, or (at your option) any later version.
8
 
9
   The GNU C Library is distributed in the hope that it will be useful,
10
   but WITHOUT ANY WARRANTY; without even the implied warranty of
11
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
   Lesser General Public License for more details.
13
 
14
   You should have received a copy of the GNU Lesser General Public
15
   License along with the GNU C Library; if not, write to the Free
16
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
17
   02111-1307 USA.  */
18
 
19
/*
20
 *      ISO C99 Standard: 7.21 String handling  <string.h>
21
 */
22
 
23
#ifndef _STRING_H
24
#define _STRING_H       1
25
 
26
#include <features.h>
27
 
28
__BEGIN_DECLS
29
 
30
/* Get size_t and NULL from <stddef.h>.  */
31
#define __need_size_t
32
#define __need_NULL
33
#include <stddef.h>
34
 
35
 
36
__BEGIN_NAMESPACE_STD
37
/* Copy N bytes of SRC to DEST.  */
38
extern void *memcpy (void *__restrict __dest,
39
                     __const void *__restrict __src, size_t __n) __THROW;
40
/* Copy N bytes of SRC to DEST, guaranteeing
41
   correct behavior for overlapping strings.  */
42
extern void *memmove (void *__dest, __const void *__src, size_t __n)
43
     __THROW;
44
__END_NAMESPACE_STD
45
 
46
/* Copy no more than N bytes of SRC to DEST, stopping when C is found.
47
   Return the position in DEST one byte past where C was copied,
48
   or NULL if C was not found in the first N bytes of SRC.  */
49
#if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN
50
extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
51
                      int __c, size_t __n)
52
     __THROW;
53
#endif /* SVID.  */
54
 
55
 
56
__BEGIN_NAMESPACE_STD
57
/* Set N bytes of S to C.  */
58
extern void *memset (void *__s, int __c, size_t __n) __THROW;
59
 
60
/* Compare N bytes of S1 and S2.  */
61
extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
62
     __THROW __attribute_pure__;
63
 
64
/* Search N bytes of S for C.  */
65
extern void *memchr (__const void *__s, int __c, size_t __n)
66
      __THROW __attribute_pure__;
67
__END_NAMESPACE_STD
68
 
69
#ifdef __USE_GNU
70
/* Search in S for C.  This is similar to `memchr' but there is no
71
   length limit.  */
72
extern void *rawmemchr (__const void *__s, int __c) __THROW __attribute_pure__;
73
 
74
/* Search N bytes of S for the final occurrence of C.  */
75
extern void *memrchr (__const void *__s, int __c, size_t __n)
76
      __THROW __attribute_pure__;
77
#endif
78
 
79
 
80
__BEGIN_NAMESPACE_STD
81
/* Copy SRC to DEST.  */
82
extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
83
     __THROW;
84
/* Copy no more than N characters of SRC to DEST.  */
85
extern char *strncpy (char *__restrict __dest,
86
                      __const char *__restrict __src, size_t __n) __THROW;
87
 
88
/* Append SRC onto DEST.  */
89
extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
90
     __THROW;
91
/* Append no more than N characters from SRC onto DEST.  */
92
extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
93
                      size_t __n) __THROW;
94
 
95
/* Compare S1 and S2.  */
96
extern int strcmp (__const char *__s1, __const char *__s2)
97
     __THROW __attribute_pure__;
98
/* Compare N characters of S1 and S2.  */
99
extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
100
     __THROW __attribute_pure__;
101
 
102
/* Compare the collated forms of S1 and S2.  */
103
extern int strcoll (__const char *__s1, __const char *__s2)
104
     __THROW __attribute_pure__;
105
/* Put a transformation of SRC into no more than N bytes of DEST.  */
106
extern size_t strxfrm (char *__restrict __dest,
107
                       __const char *__restrict __src, size_t __n) __THROW;
108
__END_NAMESPACE_STD
109
 
110
#ifdef __UCLIBC_HAS_XLOCALE__
111
#ifdef __USE_GNU
112
/* The following functions are equivalent to the both above but they
113
   take the locale they use for the collation as an extra argument.
114
   This is not standardsized but something like will come.  */
115
# include <xlocale.h>
116
 
117
/* Compare the collated forms of S1 and S2 using rules from L.  */
118
extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
119
     __THROW __attribute_pure__;
120
extern int __strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
121
     __THROW __attribute_pure__;
122
 
123
/* Put a transformation of SRC into no more than N bytes of DEST.  */
124
extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
125
                         __locale_t __l) __THROW;
126
extern size_t __strxfrm_l (char *__dest, __const char *__src, size_t __n,
127
                         __locale_t __l) __THROW;
128
 
129
#endif
130
#endif
131
 
132
#if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED
133
/* Duplicate S, returning an identical malloc'd string.  */
134
extern char *strdup (__const char *__s) __THROW __attribute_malloc__;
135
#endif
136
 
137
/* Return a malloc'd copy of at most N bytes of STRING.  The
138
   resultant string is terminated even if no null terminator
139
   appears before STRING[N].  */
140
#if defined __USE_GNU
141
extern char *strndup (__const char *__string, size_t __n)
142
     __THROW __attribute_malloc__;
143
#endif
144
 
145
#if defined __USE_GNU && defined __GNUC__
146
/* Duplicate S, returning an identical alloca'd string.  */
147
# define strdupa(s)                                                           \
148
  (__extension__                                                              \
149
    ({                                                                        \
150
      __const char *__old = (s);                                              \
151
      size_t __len = strlen (__old) + 1;                                      \
152
      char *__new = (char *) __builtin_alloca (__len);                        \
153
      (char *) memcpy (__new, __old, __len);                                  \
154
    }))
155
 
156
/* Return an alloca'd copy of at most N bytes of string.  */
157
# define strndupa(s, n)                                                       \
158
  (__extension__                                                              \
159
    ({                                                                        \
160
      __const char *__old = (s);                                              \
161
      size_t __len = strnlen (__old, (n));                                    \
162
      char *__new = (char *) __builtin_alloca (__len + 1);                    \
163
      __new[__len] = '\0';                                                    \
164
      (char *) memcpy (__new, __old, __len);                                  \
165
    }))
166
#endif
167
 
168
__BEGIN_NAMESPACE_STD
169
/* Find the first occurrence of C in S.  */
170
extern char *strchr (__const char *__s, int __c) __THROW __attribute_pure__;
171
/* Find the last occurrence of C in S.  */
172
extern char *strrchr (__const char *__s, int __c) __THROW __attribute_pure__;
173
__END_NAMESPACE_STD
174
 
175
#ifdef __USE_GNU
176
/* This function is similar to `strchr'.  But it returns a pointer to
177
   the closing NUL byte in case C is not found in S.  */
178
extern char *strchrnul (__const char *__s, int __c) __THROW __attribute_pure__;
179
#endif
180
 
181
__BEGIN_NAMESPACE_STD
182
/* Return the length of the initial segment of S which
183
   consists entirely of characters not in REJECT.  */
184
extern size_t strcspn (__const char *__s, __const char *__reject)
185
     __THROW __attribute_pure__;
186
/* Return the length of the initial segment of S which
187
   consists entirely of characters in ACCEPT.  */
188
extern size_t strspn (__const char *__s, __const char *__accept)
189
     __THROW __attribute_pure__;
190
/* Find the first occurrence in S of any character in ACCEPT.  */
191
extern char *strpbrk (__const char *__s, __const char *__accept)
192
     __THROW __attribute_pure__;
193
/* Find the first occurrence of NEEDLE in HAYSTACK.  */
194
extern char *strstr (__const char *__haystack, __const char *__needle)
195
     __THROW __attribute_pure__;
196
 
197
 
198
/* Divide S into tokens separated by characters in DELIM.  */
199
extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
200
     __THROW;
201
__END_NAMESPACE_STD
202
 
203
/* Divide S into tokens separated by characters in DELIM.  Information
204
   passed between calls are stored in SAVE_PTR.  */
205
extern char *__strtok_r (char *__restrict __s,
206
                         __const char *__restrict __delim,
207
                         char **__restrict __save_ptr) __THROW;
208
#if defined __USE_POSIX || defined __USE_MISC
209
extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
210
                       char **__restrict __save_ptr) __THROW;
211
#endif
212
 
213
#ifdef __USE_GNU
214
/* Similar to `strstr' but this function ignores the case of both strings.  */
215
extern char *strcasestr (__const char *__haystack, __const char *__needle)
216
     __THROW __attribute_pure__;
217
#endif
218
 
219
#ifdef __USE_GNU
220
/* Find the first occurrence of NEEDLE in HAYSTACK.
221
   NEEDLE is NEEDLELEN bytes long;
222
   HAYSTACK is HAYSTACKLEN bytes long.  */
223
extern void *memmem (__const void *__haystack, size_t __haystacklen,
224
                     __const void *__needle, size_t __needlelen)
225
     __THROW __attribute_pure__;
226
 
227
/* Copy N bytes of SRC to DEST, return pointer to bytes after the
228
   last written byte.  */
229
extern void *__mempcpy (void *__restrict __dest,
230
                        __const void *__restrict __src, size_t __n) __THROW;
231
extern void *mempcpy (void *__restrict __dest,
232
                      __const void *__restrict __src, size_t __n) __THROW;
233
#endif
234
 
235
 
236
__BEGIN_NAMESPACE_STD
237
/* Return the length of S.  */
238
extern size_t strlen (__const char *__s) __THROW __attribute_pure__;
239
__END_NAMESPACE_STD
240
 
241
#ifdef  __USE_GNU
242
/* Find the length of STRING, but scan at most MAXLEN characters.
243
   If no '\0' terminator is found in that many characters, return MAXLEN.  */
244
extern size_t strnlen (__const char *__string, size_t __maxlen)
245
     __THROW __attribute_pure__;
246
#endif
247
 
248
 
249
__BEGIN_NAMESPACE_STD
250
/* Return a string describing the meaning of the `errno' code in ERRNUM.  */
251
extern char *strerror (int __errnum) __THROW;
252
__END_NAMESPACE_STD
253
#if defined __USE_XOPEN2K || defined __USE_MISC
254
/* Reentrant version of `strerror'.  If a temporary buffer is required, at
255
   most BUFLEN bytes of BUF will be used.  */
256
/* extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) __THROW; */
257
 
258
/* uClibc Note: glibc's strerror_r is different from that specified in SUSv3.
259
 * So we try to compensate based on feature macros. */
260
extern char *_glibc_strerror_r (int __errnum, char *__buf, size_t __buflen) __THROW;
261
extern int _susv3_strerror_r (int __errnum, char *__buf, size_t buflen) __THROW;
262
 
263
#if defined(__USE_XOPEN2K) && !defined(__USE_GNU)
264
# ifdef __REDIRECT
265
extern int __REDIRECT (strerror_r,
266
                       (int __errnum, char *__buf, size_t buflen) __THROW,
267
                       _susv3_strerror_r);
268
# else
269
#  define strerror_r _susv3_strerror_r
270
# endif
271
#else  /* defined(__USE_XOPEN2K) && !defined(__USE_GNU) */
272
# ifdef __REDIRECT
273
extern char *__REDIRECT (strerror_r,
274
                         (int __errnum, char *__buf, size_t buflen) __THROW,
275
                         _glibc_strerror_r);
276
# else
277
#  define strerror_r _glibc_strerror_r
278
# endif
279
#endif /* defined(__USE_XOPEN2K) && !defined(__USE_GNU) */
280
#endif
281
 
282
/* We define this function always since `bzero' is sometimes needed when
283
   the namespace rules does not allow this.  */
284
extern void __bzero (void *__s, size_t __n) __THROW;
285
 
286
#ifdef __USE_BSD
287
/* Copy N bytes of SRC to DEST (like memmove, but args reversed).  */
288
extern void bcopy (__const void *__src, void *__dest, size_t __n) __THROW;
289
 
290
/* Set N bytes of S to 0.  */
291
extern void bzero (void *__s, size_t __n) __THROW;
292
 
293
/* Compare N bytes of S1 and S2 (same as memcmp).  */
294
extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
295
     __THROW __attribute_pure__;
296
 
297
/* Find the first occurrence of C in S (same as strchr).  */
298
extern char *index (__const char *__s, int __c) __THROW __attribute_pure__;
299
 
300
/* Find the last occurrence of C in S (same as strrchr).  */
301
extern char *rindex (__const char *__s, int __c) __THROW __attribute_pure__;
302
 
303
/* Return the position of the first bit set in I, or 0 if none are set.
304
   The least-significant bit is position 1, the most-significant 32.  */
305
extern int ffs (int __i) __THROW __attribute__ ((__const__));
306
 
307
/* The following two functions are non-standard but necessary for non-32 bit
308
   platforms.  */
309
# ifdef __USE_GNU
310
extern int ffsl (long int __l) __THROW __attribute__ ((__const__));
311
#  ifdef __GNUC__
312
__extension__ extern int ffsll (long long int __ll)
313
     __THROW __attribute__ ((__const__));
314
#  endif
315
# endif
316
 
317
/* Compare S1 and S2, ignoring case.  */
318
extern int strcasecmp (__const char *__s1, __const char *__s2)
319
     __THROW __attribute_pure__;
320
 
321
/* Compare no more than N chars of S1 and S2, ignoring case.  */
322
extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
323
     __THROW __attribute_pure__;
324
#endif /* Use BSD.  */
325
 
326
#ifdef __UCLIBC_HAS_XLOCALE__
327
#ifdef  __USE_GNU
328
/* Again versions of a few functions which use the given locale instead
329
   of the global one.  */
330
extern int strcasecmp_l (__const char *__s1, __const char *__s2,
331
                         __locale_t __loc) __THROW __attribute_pure__;
332
extern int __strcasecmp_l (__const char *__s1, __const char *__s2,
333
                         __locale_t __loc) __THROW __attribute_pure__;
334
 
335
extern int strncasecmp_l (__const char *__s1, __const char *__s2,
336
                          size_t __n, __locale_t __loc)
337
     __THROW __attribute_pure__;
338
extern int __strncasecmp_l (__const char *__s1, __const char *__s2,
339
                          size_t __n, __locale_t __loc)
340
     __THROW __attribute_pure__;
341
#endif
342
#endif
343
 
344
#ifdef  __USE_BSD
345
/* Return the next DELIM-delimited token from *STRINGP,
346
   terminating it with a '\0', and update *STRINGP to point past it.  */
347
extern char *strsep (char **__restrict __stringp,
348
                     __const char *__restrict __delim) __THROW;
349
#endif
350
 
351
#ifdef  __USE_GNU
352
#if 0
353
/* Compare S1 and S2 as strings holding name & indices/version numbers.  */
354
extern int strverscmp (__const char *__s1, __const char *__s2)
355
     __THROW __attribute_pure__;
356
#endif
357
 
358
/* Return a string describing the meaning of the signal number in SIG.  */
359
extern char *strsignal (int __sig) __THROW;
360
 
361
/* Copy SRC to DEST, returning the address of the terminating '\0' in DEST.  */
362
extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
363
     __THROW;
364
extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
365
     __THROW;
366
 
367
/* Copy no more than N characters of SRC to DEST, returning the address of
368
   the last character written into DEST.  */
369
extern char *__stpncpy (char *__restrict __dest,
370
                        __const char *__restrict __src, size_t __n) __THROW;
371
extern char *stpncpy (char *__restrict __dest,
372
                      __const char *__restrict __src, size_t __n) __THROW;
373
 
374
#if 0
375
/* Sautee STRING briskly.  */
376
extern char *strfry (char *__string) __THROW;
377
 
378
/* Frobnicate N bytes of S.  */
379
extern void *memfrob (void *__s, size_t __n) __THROW;
380
#endif
381
 
382
# ifndef basename
383
/* Return the file name within directory of FILENAME.  We don't
384
   declare the function if the `basename' macro is available (defined
385
   in <libgen.h>) which makes the XPG version of this function
386
   available.  */
387
extern char *basename (__const char *__filename) __THROW;
388
# endif
389
#endif
390
 
391
 
392
#if 0
393
#if defined __GNUC__ && __GNUC__ >= 2
394
# if defined __OPTIMIZE__ && !defined __OPTIMIZE_SIZE__ \
395
     && !defined __NO_INLINE__ && !defined __cplusplus
396
/* When using GNU CC we provide some optimized versions of selected
397
   functions from this header.  There are two kinds of optimizations:
398
 
399
   - machine-dependent optimizations, most probably using inline
400
     assembler code; these might be quite expensive since the code
401
     size can increase significantly.
402
     These optimizations are not used unless the symbol
403
        __USE_STRING_INLINES
404
     is defined before including this header.
405
 
406
   - machine-independent optimizations which do not increase the
407
     code size significantly and which optimize mainly situations
408
     where one or more arguments are compile-time constants.
409
     These optimizations are used always when the compiler is
410
     taught to optimize.
411
 
412
   One can inhibit all optimizations by defining __NO_STRING_INLINES.  */
413
 
414
/* Get the machine-dependent optimizations (if any).  */
415
#  include <bits/string.h>
416
 
417
/* These are generic optimizations which do not add too much inline code.  */
418
#  include <bits/string2.h>
419
# endif
420
#endif
421
#endif
422
 
423
#ifdef  __USE_BSD
424
/* Two OpenBSD extension functions. */
425
extern size_t strlcat(char *__restrict dst, const char *__restrict src,
426
                      size_t n) __THROW;
427
extern size_t strlcpy(char *__restrict dst, const char *__restrict src,
428
                      size_t n) __THROW;
429
#endif
430
 
431
__END_DECLS
432
 
433
#endif /* string.h  */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.