Debian Codegraph @

share/libc/string.h

raw
1 /**************************************************************************/
2 /* */
3 /* This file is part of Frama-C. */
4 /* */
5 /* Copyright (C) 2007-2022 */
6 /* CEA (Commissariat à l'énergie atomique et aux énergies */
7 /* alternatives) */
8 /* */
9 /* you can redistribute it and/or modify it under the terms of the GNU */
10 /* Lesser General Public License as published by the Free Software */
11 /* Foundation, version 2.1. */
12 /* */
13 /* It is distributed in the hope that it will be useful, */
14 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
15 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
16 /* GNU Lesser General Public License for more details. */
17 /* */
18 /* See the GNU Lesser General Public License version 2.1 */
19 /* for more details (enclosed in the file licenses/LGPLv2.1). */
20 /* */
21 /**************************************************************************/
22
23 #ifndef __FC_STRING_H_
24 #define __FC_STRING_H_
25
26 #include "features.h"
27 __PUSH_FC_STDLIB
28 #include "__fc_string_axiomatic.h"
29 #include "__fc_alloc_axiomatic.h"
30 #include "stddef.h"
31 #include "limits.h"
32
33 __BEGIN_DECLS
34
35 // Query memory
36
37 /*@ predicate non_escaping{L}(void *s, integer n) =
38 \forall integer i; 0 <= i < n ==> !\dangling((char *)s + i);
39 */
40
41 /*@
42 predicate empty_block{L}(void *s) =
43 \block_length((char*)s) == 0 && \offset((char*)s) == 0;
44
45 // Note: the [\valid_read] below is intentional: if [malloc(0)] may return a
46 // const base, then [memset(p, 0, 0)] requires p to have a readable
47 // (but not writable) byte.
48 predicate valid_or_empty{L}(void *s, size_t n) =
49 (empty_block(s) || \valid_read((char*)s)) && \valid(((char*)s)+(0..n-1));
50
51 predicate valid_read_or_empty{L}(void *s, size_t n) =
52 (empty_block(s) || \valid_read((char*)s)) && \valid_read(((char*)s)+(1..n-1));
53 */
54
55 /*@ requires valid_s1: valid_read_or_empty(s1, n);
56 @ requires valid_s2: valid_read_or_empty(s2, n);
57 @ requires initialization:s1: \initialized(((char*)s1)+(0..n - 1));
58 @ requires initialization:s2: \initialized(((char*)s2)+(0..n - 1));
59 @ requires danglingness:s1: non_escaping(s1, n);
60 @ requires danglingness:s2: non_escaping(s2, n);
61 @ assigns \result \from
62 @ indirect:((char*)s1)[0.. n-1], indirect:((char*)s2)[0.. n-1];
63 @ ensures logic_spec: \result == memcmp{Pre,Pre}((char*)s1,(char*)s2,n);
64 @*/
65 extern int memcmp (const void *s1, const void *s2, size_t n);
66
67 /*@ requires valid:
68 valid_read_or_empty(s, n)
69 || \valid_read(((unsigned char*)s)+(0..memchr_off((char*)s,c,n)));
70 @ requires initialization:
71 \initialized(((unsigned char*)s)+(0..n - 1))
72 || \initialized(((unsigned char*)s)+(0..memchr_off((char*)s,c,n)));
73 @ requires danglingness:
74 non_escaping(s, n)
75 || non_escaping(s, (size_t)(memchr_off((char*)s,c,n)+1));
76 @ assigns \result \from s, c, ((unsigned char*)s)[0..n-1];
77 @ behavior found:
78 @ assumes char_found: memchr((char*)s,c,n);
79 @ ensures result_same_base: \base_addr(\result) == \base_addr(s);
80 @ ensures result_char: *(char*)\result == c;
81 @ ensures result_in_str: \forall integer i;
82 @ 0 <= i < n ==> *((unsigned char*)s+i) == c
83 @ ==> (unsigned char*)\result <= (unsigned char*)s+i;
84 @ behavior not_found:
85 @ assumes char_not_found: !memchr((char*)s,c,n);
86 @ ensures result_null: \result == \null;
87 @*/
88 extern void *memchr(const void *s, int c, size_t n);
89
90 // Non-POSIX; GNU extension
91 extern void *memrchr(const void *s, int c, size_t n);
92
93 // Copy memory
94
95 /*@ requires valid_dest: valid_or_empty(dest, n);
96 @ requires valid_src: valid_read_or_empty(src, n);
97 @ requires separation:
98 @ \separated(((char *)dest)+(0..n-1),((char *)src)+(0..n-1));
99 @ assigns ((char*)dest)[0..n - 1] \from ((char*)src)[0..n-1];
100 @ assigns \result \from dest;
101 @ ensures copied_contents: memcmp{Post,Pre}((char*)dest,(char*)src,n) == 0;
102 @ ensures result_ptr: \result == dest;
103 @*/
104 extern void *memcpy(void *restrict dest,
105 const void *restrict src, size_t n);
106
107 // Non-POSIX; GNU extension
108 /*@ requires valid_dest: valid_or_empty(dest, n);
109 @ requires valid_src: valid_read_or_empty(src, n);
110 @ requires separation:
111 @ \separated(((char *)dest)+(0..n-1),((char *)src)+(0..n-1));
112 @ assigns ((char*)dest)[0..n - 1] \from ((char*)src)[0..n-1];
113 @ assigns \result \from dest, n;
114 @ ensures copied_contents: memcmp{Post,Pre}((char*)dest,(char*)src,n) == 0;
115 @ ensures result_next_byte: \result == dest + n;
116 @*/
117 extern void *mempcpy(void *restrict dest,
118 const void *restrict src, size_t n);
119
120 /*@ requires valid_dest: valid_or_empty(dest, n);
121 @ requires valid_src: valid_read_or_empty(src, n);
122 @ assigns ((char*)dest)[0..n - 1] \from ((char*)src)[0..n-1];
123 @ assigns \result \from dest;
124 @ ensures copied_contents: memcmp{Post,Pre}((char*)dest,(char*)src,n) == 0;
125 @ ensures result_ptr: \result == dest;
126 @*/
127 extern void *memmove(void *dest, const void *src, size_t n);
128
129 // Set memory
130
131 /*@ requires valid_s: valid_or_empty(s, n);
132 @ assigns ((char*)s)[0..n - 1] \from c;
133 @ assigns \result \from s;
134 @ ensures acsl_c_equiv: memset((char*)s,c,n);
135 @ ensures result_ptr: \result == s;
136 @*/
137 extern void *memset(void *s, int c, size_t n);
138
139 // Query strings
140
141 /*@ requires valid_string_s: valid_read_string(s);
142 @ assigns \result \from indirect:s[0..];
143 @ ensures acsl_c_equiv: \result == strlen(s);
144 @*/
145 extern size_t strlen (const char *s);
146
147 /*@ requires valid_string_s: valid_read_nstring(s, n);
148 @ assigns \result \from indirect:s[0..n-1], indirect:n;
149 @ ensures result_bounded: \result == strlen(s) || \result == n;
150 @*/
151 extern size_t strnlen (const char *s, size_t n);
152
153 /*@ requires valid_string_s1: valid_read_string(s1);
154 @ requires valid_string_s2: valid_read_string(s2);
155 @ assigns \result \from indirect:s1[0..], indirect:s2[0..];
156 @ ensures acsl_c_equiv: \result == strcmp(s1,s2);
157 @*/
158 extern int strcmp (const char *s1, const char *s2);
159
160 /*@ requires valid_string_s1: valid_read_nstring(s1, n); // over-strong
161 @ requires valid_string_s2: valid_read_nstring(s2, n); // over-strong
162 @ assigns \result \from indirect:s1[0 .. n-1], indirect:s2[0 ..n-1], indirect:n;
163 @ ensures acsl_c_equiv: \result == strncmp(s1,s2,n);
164 @*/
165 extern int strncmp (const char *s1, const char *s2, size_t n);
166
167 /*@ requires valid_string_s1: valid_read_string(s1); // over-strong
168 @ requires valid_string_s2: valid_read_string(s2); // over-strong
169 @ assigns \result \from indirect:s1[0..], indirect:s2[0..];
170 @*/
171 extern int strcoll (const char *s1, const char *s2);
172
173 /*@ requires valid_string_s: valid_read_string(s);
174 @ assigns \result \from s, indirect:s[0..strlen(s)], indirect:c;
175 @ behavior found:
176 @ assumes char_found: strchr(s,c);
177 @ ensures result_char: *\result == (char)c;
178 @ ensures result_same_base: \base_addr(\result) == \base_addr(s);
179 @ ensures result_in_length: s <= \result <= s + strlen(s);
180 @ ensures result_valid_string: valid_read_string(\result);
181 @ ensures result_first_occur: \forall char* p; s<=p<\result ==> *p != (char)c;
182 @ behavior not_found:
183 @ assumes char_not_found: !strchr(s,c);
184 @ ensures result_null: \result == \null;
185 @ behavior default:
186 @ ensures result_null_or_same_base:
187 @ \result == \null || \base_addr(\result) == \base_addr(s);
188 @*/
189 extern char *strchr(const char *s, int c);
190
191 /*@ requires valid_string_s: valid_read_string(s);
192 @ assigns \result \from s, indirect:s[0..strlen(s)], indirect:c;
193 @ ensures result_same_base: \subset(\result, s+(0..strlen(s)));
194 @*/
195 extern char *strchrnul(const char *s, int c);
196
197 /*@ requires valid_string_s: valid_read_string(s);
198 @ assigns \result \from s, s[0..],c;
199 @ behavior found:
200 @ assumes char_found: strchr(s,c);
201 @ ensures result_char: *\result == c;
202 @ ensures result_same_base: \base_addr(\result) == \base_addr(s);
203 @ ensures result_valid_string: valid_read_string(\result);
204 @ behavior not_found:
205 @ assumes char_not_found: !strchr(s,c);
206 @ ensures result_null: \result == \null;
207 @ behavior default:
208 @ ensures result_null_or_same_base:
209 @ \result == \null || \base_addr(\result) == \base_addr(s);
210 @*/
211 extern char *strrchr(const char *s, int c);
212
213 /*@ requires valid_string_s: valid_read_string(s);
214 @ requires valid_string_reject: valid_read_string(reject);
215 @ assigns \result \from indirect:s[0..], indirect:reject[0..];
216 @ ensures result_bounded: 0 <= \result <= strlen(s);
217 @*/
218 extern size_t strcspn(const char *s, const char *reject);
219
220 /*@ requires valid_string_s: valid_read_string(s);
221 @ requires valid_string_accept: valid_read_string(accept);
222 @ assigns \result \from s[0..], accept[0..];
223 @ assigns \result \from indirect:s[0..], indirect:accept[0..];
224 @ ensures result_bounded: 0 <= \result <= strlen(s);
225 @*/
226 extern size_t strspn(const char *s, const char *accept);
227
228 /*@ requires valid_string_s: valid_read_string(s);
229 @ requires valid_string_accept: valid_read_string(accept);
230 @ assigns \result \from s, s[0..], accept[0..];
231 @ ensures result_null_or_same_base:
232 @ \result == \null || \base_addr(\result) == \base_addr(s);
233 @*/
234 extern char *strpbrk(const char *s, const char *accept);
235
236 /*@ requires valid_string_haystack: valid_read_string(haystack);
237 @ requires valid_string_needle: valid_read_string(needle);
238 @ assigns \result \from haystack, indirect:haystack[0..],
239 @ indirect:needle[0..];
240 @ ensures result_null_or_in_haystack:
241 @ \result == \null
242 @ || (\subset(\result, haystack+(0..)) && \valid_read(\result)
243 @ && memcmp{Pre,Pre}(\result,needle,strlen(needle)) == 0);
244 @*/
245 extern char *strstr(const char *haystack, const char *needle);
246
247 /*@ requires valid_string_haystack: valid_read_string(haystack);
248 @ requires valid_string_needle: valid_read_string(needle);
249 @ assigns \result \from haystack, indirect:haystack[0..],
250 @ indirect:needle[0..];
251 @ ensures result_null_or_in_haystack:
252 @ \result == \null
253 @ || (\subset(\result, haystack+(0..)) && \valid_read(\result));
254 @*/
255 extern char *strcasestr (const char *haystack, const char *needle);
256
257 // internal state of strtok
258 char *__fc_strtok_ptr;
259
260 /*@ // missing: separation
261 requires valid_string_delim: valid_read_string(delim);
262 assigns s[0..] \from s[0..],
263 indirect:s, indirect:__fc_strtok_ptr, indirect:delim[0..];
264 assigns __fc_strtok_ptr[0..] \from __fc_strtok_ptr[0..],
265 indirect:s, indirect:__fc_strtok_ptr, indirect:delim[0..];
266 assigns \result \from s, __fc_strtok_ptr, indirect:s[0..],
267 indirect:__fc_strtok_ptr[0..], indirect:delim[0..];
268 assigns __fc_strtok_ptr \from \old(__fc_strtok_ptr), s,
269 indirect:__fc_strtok_ptr[0..],
270 indirect:delim[0..];
271 behavior new_str:
272 assumes s_not_null: s != \null;
273 requires valid_string_s_or_delim_not_found:
274 valid_string(s) ||
275 (valid_read_string(s) &&
276 \forall int i; 0 <= i < strlen(delim) ==> !strchr(s,delim[i]));
277 assigns __fc_strtok_ptr \from s, indirect:s[0..], indirect:delim[0..];
278 assigns s[0..] \from s[0..], indirect:s, indirect:delim[0..];
279 assigns \result \from s, indirect:s[0..], indirect:delim[0..];
280 ensures result_subset: \result == \null || \subset(\result, s+(0..));
281 ensures ptr_subset: \subset(__fc_strtok_ptr, s+(0..));
282 behavior resume_str:
283 assumes s_null: s == \null;
284 requires not_first_call: __fc_strtok_ptr != \null;
285 assigns __fc_strtok_ptr[0..] \from __fc_strtok_ptr[0..],
286 indirect:__fc_strtok_ptr,
287 indirect:delim[0..];
288 assigns __fc_strtok_ptr \from \old(__fc_strtok_ptr),
289 indirect:__fc_strtok_ptr[0..],
290 indirect:delim[0..];
291 assigns \result \from __fc_strtok_ptr, indirect:__fc_strtok_ptr[0..],
292 indirect:delim[0..];
293 ensures result_subset: \result == \null ||
294 \subset(\result, \old(__fc_strtok_ptr)+(0..));
295 ensures ptr_subset: \subset(__fc_strtok_ptr, \old(__fc_strtok_ptr)+(0..));
296 complete behaviors;
297 disjoint behaviors;
298 */
299 extern char *strtok(char *restrict s, const char *restrict delim);
300
301 /*@ // missing: separation
302 requires valid_string_delim: valid_read_string(delim);
303 requires valid_saveptr: \valid(saveptr);
304 assigns s[0..] \from s[0..],
305 indirect:s, indirect:*saveptr, indirect:delim[0..];
306 assigns (*saveptr)[0..] \from (*saveptr)[0..],
307 indirect:s, indirect:*saveptr, indirect:delim[0..];
308 assigns \result \from s, *saveptr, indirect:s[0..],
309 indirect:(*saveptr)[0..], indirect:delim[0..];
310 assigns *saveptr \from \old(*saveptr), s,
311 indirect:(*saveptr)[0..],
312 indirect:delim[0..];
313 behavior new_str:
314 assumes s_not_null: s != \null;
315 requires valid_string_s_or_delim_not_found:
316 valid_string(s) ||
317 (valid_read_string(s) &&
318 \forall int i; 0 <= i < strlen(delim) ==> !strchr(s,delim[i]));
319 assigns *saveptr \from s, indirect:s[0..], indirect:delim[0..];
320 assigns s[0..] \from s[0..], indirect:s, indirect:delim[0..];
321 assigns \result \from s, indirect:s[0..], indirect:delim[0..];
322 ensures result_subset: \result == \null || \subset(\result, s+(0..));
323 ensures initialization: \initialized(saveptr);
324 ensures saveptr_subset: \subset(*saveptr, s+(0..));
325 behavior resume_str:
326 assumes s_null: s == \null;
327 requires not_first_call: *saveptr != \null;
328 requires initialization:saveptr: \initialized(saveptr);
329 assigns (*saveptr)[0..] \from (*saveptr)[0..],
330 indirect:*saveptr,
331 indirect:delim[0..];
332 assigns *saveptr \from \old(*saveptr),
333 indirect:(*saveptr)[0..],
334 indirect:delim[0..];
335 assigns \result \from *saveptr, indirect:(*saveptr)[0..],
336 indirect:delim[0..];
337 ensures result_subset: \result == \null ||
338 \subset(\result, \old(*saveptr)+(0..));
339 ensures saveptr_subset: \subset(*saveptr, \old(*saveptr)+(0..));
340 complete behaviors;
341 disjoint behaviors;
342 */
343 extern char *strtok_r(char *restrict s, const char *restrict delim, char **restrict saveptr);
344
345 /*@ requires valid_string_stringp: \valid(stringp) && valid_string(*stringp);
346 @ requires valid_string_delim: valid_read_string(delim);
347 @ assigns *stringp \from delim[..], *stringp[..];
348 @ assigns \result \from delim[..], *stringp[..];
349 @*/
350 extern char *strsep (char **stringp, const char *delim);
351
352 __FC_EXTERN char __fc_strerror[64];
353 char * const __fc_p_strerror = __fc_strerror;
354
355 // Note: postcondition "result_nul_terminated" is only a temporary patch,
356 // to help plug-ins which are currently unable to reduce the post-state
357 // using only 'result_valid_string'.
358 /*@ assigns \result \from __fc_p_strerror, indirect:errnum;
359 @ ensures result_internal_str: \result == __fc_p_strerror;
360 @ ensures result_nul_terminated: \result[63] == 0;
361 @ ensures result_valid_string: valid_read_string(\result);
362 @*/
363 extern char *strerror(int errnum);
364
365 // Copy strings
366
367 /*@ requires valid_string_src: valid_read_string(src);
368 @ requires room_string: \valid(dest+(0..strlen(src)));
369 @ requires separation:
370 @ \separated(dest+(0..strlen(src)), src+(0..strlen(src)));
371 @ assigns dest[0..strlen(src)] \from src[0..strlen(src)];
372 @ assigns \result \from dest;
373 @ ensures equal_contents: strcmp(dest,src) == 0;
374 @ ensures result_ptr: \result == dest;
375 @*/
376 extern char *strcpy(char *restrict dest, const char *restrict src);
377
378 /*@
379 @ requires valid_nstring_src: valid_read_nstring(src, n);
380 @ requires room_nstring: \valid(dest+(0 .. n-1));
381 @ requires separation:
382 @ \separated(dest+(0..n-1), src+(0..n-1));
383 @ assigns dest[0..n - 1] \from src[0..n-1];
384 @ assigns \result \from dest;
385 @ ensures result_ptr: \result == dest;
386 @ ensures initialization: \initialized(dest+(0 .. n-1));
387 @ behavior complete:
388 @ assumes src_fits: strlen(src) < n;
389 @ ensures equal_after_copy: strcmp(dest,src) == 0;
390 @ behavior partial:
391 @ assumes src_too_long: n <= strlen(src);
392 @ ensures equal_prefix: memcmp{Post,Post}(dest,src,n) == 0;
393 @*/
394 extern char *strncpy(char *restrict dest,
395 const char *restrict src, size_t n);
396
397 /*@ // Non-POSIX, but often present; note that, unlike strncpy, this has no
398 @ // "official specification" other than manpages. They state that src is
399 @ // a *string*, therefore its precondition is stricter than that of strncpy.
400 @ requires valid_string_src: valid_read_string(src);
401 @ requires room_nstring: \valid(dest+(0..n-1));
402 @ requires separation:
403 @ \separated(dest+(0..n-1), src+(0..\max(n-1,strlen(src))));
404 @ assigns dest[0..n-1] \from src[0..n-1];
405 @ assigns \result \from indirect:src, indirect:src[0..n-1], indirect:n;
406 @ ensures initialization: \initialized(dest+(0..\min(strlen(src),n-1)));
407 @ ensures bounded_result: \result == strlen(src);
408 */
409 size_t strlcpy(char * restrict dest, const char * restrict src, size_t n);
410
411 // stpcpy is POSIX.1-2008
412 /*@ requires valid_string_src: valid_read_string(src);
413 @ requires room_string: \valid(dest+(0..strlen(src)));
414 @ requires separation:
415 @ \separated(dest+(0..strlen(src)), src+(0..strlen(src)));
416 @ assigns dest[0..strlen(src)] \from src[0..strlen(src)];
417 @ assigns \result \from dest;
418 @ ensures equal_contents: strcmp(dest,src) == 0;
419 @ ensures points_to_end: \result == dest + strlen(dest);
420 @*/
421 extern char *stpcpy(char *restrict dest, const char *restrict src);
422
423 /*@ // missing: separation
424 @ requires valid_string_src: valid_read_string(src);
425 @ requires valid_string_dest: valid_string(dest);
426 @ requires room_string: \valid(dest+(0..strlen(dest) + strlen(src)));
427 @ assigns dest[strlen(dest)..strlen(dest) + strlen(src)]
428 @ \from src[0..strlen(src)];
429 @ ensures sum_of_lengths: strlen(dest) == \old(strlen(dest) + strlen(src));
430 @ assigns \result \from dest;
431 @ ensures initialization:dest:
432 @ \initialized(dest+(0..\old(strlen(dest) + strlen(src))));
433 @ ensures dest_null_terminated: dest[\old(strlen(dest) + strlen(src))] == 0;
434 @ ensures result_ptr: \result == dest;
435 @*/
436 extern char *strcat(char *restrict dest, const char *restrict src);
437
438 /*@ // missing: separation
439 @ requires valid_nstring_src: valid_read_nstring(src, n);
440 @ requires valid_string_dest: valid_string(dest);
441 @ assigns dest[strlen(dest) .. strlen(dest) + n] \from src[0..n];
442 @ assigns \result \from dest;
443 @ ensures result_ptr: \result == dest;
444 @ behavior complete:
445 @ assumes valid_string_src_fits: valid_read_string(src) && strlen(src) <= n;
446 @ requires room_string: \valid(dest + strlen(dest) + (0 .. strlen(src)));
447 @ assigns dest[strlen(dest)..strlen(dest) + strlen(src)]
448 @ \from src[0..strlen(src)];
449 @ assigns \result \from dest;
450 @ ensures sum_of_lengths: strlen(dest) == \old(strlen(dest) + strlen(src));
451 @ behavior partial:
452 @ assumes valid_string_src_too_large:
453 @ !(valid_read_string(src) && strlen(src) <= n);
454 @ requires room_string: \valid(dest + strlen(dest) + (0 .. n));
455 @ assigns dest[strlen(dest)..strlen(dest) + n]
456 @ \from src[0..strlen(src)];
457 @ assigns \result \from dest;
458 @ ensures sum_of_bounded_lengths: strlen(dest) == \old(strlen(dest)) + n;
459 @*/
460 extern char *strncat(char *restrict dest, const char *restrict src, size_t n);
461
462 /*@ // Non-POSIX, but often present
463 @ // missing: separation
464 @ requires valid_string_src: valid_read_string(src);
465 @ requires valid_string_dest: valid_string(dest);
466 @ requires room_nstring: \valid(dest+(0..n-1));
467 @ assigns dest[strlen(dest)..n] \from indirect:n, src[0..strlen(src)];
468 @ assigns \result \from indirect:src, indirect:src[0..n-1], indirect:n;
469 @ ensures bounded_result: \result == strlen(dest) + strlen(src);
470 @*/
471 extern size_t strlcat(char *restrict dest, const char *restrict src, size_t n);
472
473 /*@ // missing: separation
474 @ requires valid_dest: \valid(dest+(0..n - 1));
475 @ requires valid_string_src: valid_read_string(src);
476 @ assigns dest[0..n - 1] \from indirect:src[0..], indirect:n;
477 @ assigns \result \from dest;
478 @*/
479 extern size_t strxfrm (char *restrict dest,
480 const char *restrict src, size_t n);
481
482 // Allocate strings
483
484 /*@ requires valid_string_s: valid_read_string(s);
485 @ allocates \result;
486 @ assigns \result \from indirect:s[0..strlen(s)], indirect:__fc_heap_status;
487 @ behavior allocation:
488 @ assumes can_allocate: is_allocable(strlen(s));
489 @ assigns __fc_heap_status \from indirect:s, __fc_heap_status;
490 @ assigns \result \from indirect:s[0..strlen(s)], indirect:__fc_heap_status;
491 @ ensures allocation: \fresh(\result,strlen(s));
492 @ ensures result_valid_string_and_same_contents:
493 @ valid_string(\result) && strcmp(\result,s) == 0;
494 @ behavior no_allocation:
495 @ assumes cannot_allocate: !is_allocable(strlen(s));
496 @ assigns \result \from \nothing;
497 @ allocates \nothing;
498 @ ensures result_null: \result == \null;
499 @*/
500 extern char *strdup (const char *s);
501
502 /*@ requires valid_string_s: valid_read_string(s);
503 @ allocates \result;
504 @ assigns \result \from indirect:s[0..strlen(s)], indirect:n,
505 @ indirect:__fc_heap_status;
506 @ behavior allocation:
507 @ assumes can_allocate: is_allocable(\min(strlen(s), n+1));
508 @ assigns __fc_heap_status \from indirect:s, indirect:n, __fc_heap_status;
509 @ assigns \result \from indirect:s[0..strlen(s)], indirect:n,
510 @ indirect:__fc_heap_status;
511 @ ensures allocation: \fresh(\result,\min(strlen(s), n+1));
512 @ ensures result_valid_string_bounded_and_same_prefix:
513 @ \valid(\result+(0..\min(strlen(s),n))) &&
514 @ valid_string(\result) && strlen(\result) <= n &&
515 @ strncmp(\result,s,n) == 0;
516 @ behavior no_allocation:
517 @ assumes cannot_allocate: !is_allocable(\min(strlen(s), n+1));
518 @ assigns \result \from \nothing;
519 @ allocates \nothing;
520 @ ensures result_null: \result == \null;
521 @*/
522 extern char *strndup (const char *s, size_t n);
523
524 // More POSIX, non-C99 functions
525 extern char *stpncpy(char *restrict dest, const char *restrict src, size_t n);
526 //extern int strcoll_l(const char *s1, const char *s2, locale_t locale);
527 //extern char *strerror_l(int errnum, locale_t locale);
528 extern int strerror_r(int errnum, char *strerrbuf, size_t buflen);
529
530 __FC_EXTERN char __fc_strsignal[64];
531 char * const __fc_p_strsignal = __fc_strsignal;
532
533 /*@ //missing: requires valid_signal(signum);
534 @ assigns \result \from __fc_p_strsignal, indirect:signum;
535 @ ensures result_internal_str: \result == __fc_p_strsignal;
536 @ ensures result_nul_terminated: \result[63] == 0;
537 @ ensures result_valid_string: valid_read_string(\result);
538 @*/
539 extern char *strsignal(int signum);
540
541 //extern size_t strxfrm_l(char *restrict s1, const char *restrict s2, size_t n,
542 // locale_t locale);
543
544 __END_DECLS
545
546 /* Include strings.h: this is what BSD does, and glibc does something
547 equivalent (having copied prototypes to string.h). */
548 #include "strings.h"
549
550 __POP_FC_STDLIB
551 #endif /* _STRING_H_ */