// the array s must be allocated
// n should not be greater than the size of s
// nondeterministically return 0 or a pointer within the first n elements of s
void *memchr(const void *s, int c, size_t n) {
int size;
int nondet;
int offset;
nondet = __infer_nondet_int();
offset = __infer_nondet_int();
size = __get_array_size(s);
INFER_EXCLUDE_CONDITION(n > size);
if(nondet) return 0;
INFER_EXCLUDE_CONDITION(offset < 0 || offset >= n);
return (void *)s + offset;
}
// the string s must be allocated
// assign to endptr a pointer somewhere inside the string str
// result is nondeterministic
unsigned long strtoul(const char *str, char **endptr, int base) {
int size;
int offset;
int res;
size = __get_array_size(str);
offset = __infer_nondet_int();
INFER_EXCLUDE_CONDITION(offset < 0 || offset >= size);
if(endptr) *endptr = (char *) (str + offset);
res = __infer_nondet_int();
int errno_val = __infer_nondet_int();
INFER_EXCLUDE_CONDITION(errno_val < 0);
errno = errno_val;
return res;
}
char* strchr(const char* s, int c) {
#else
// This overload is commented out on purpose.
// Standard headers define both functions with same __asm symbol which
// means they cannot be both defined. On the other hand, since both of them
// have same __asm symbol, mangling will be the same and infer will have
// specs for both functions (they both will have the same name)
// NOTE: this was tested on couple of systems, it may not be always true.
// const char* strchr(const char* s, int c) throw() { return strchr((char*)s,
// c); }
char* strchr(char* s, int c) throw() {
#endif
int size;
int nondet;
int offset;
nondet = __infer_nondet_int();
offset = __infer_nondet_int();
__require_allocated_array(s);
size = __get_array_length(s);
if (nondet)
return 0;
INFER_EXCLUDE_CONDITION(offset < 0 || offset >= size);
return (char*)s + offset;
}
void* infer__builtin___memset_chk(void* dest,
int val,
unsigned long len,
unsigned long dstlen) {
INFER_EXCLUDE_CONDITION(dstlen < len);
return dest;
}
// s needs to be allocated
// n should not be greater than the size of s
void *memset(void *s, int c, size_t n) {
int size_s;
__infer_set_flag("ignore_return", ""); // no warnings if the return value is ignored
size_s = __get_array_size(s);
INFER_EXCLUDE_CONDITION(n>size_s);
return s;
}
// the strings s1 and s2 need to be allocated
// check that n characters fit in s1 (because even if s2 is shorter than n, null characters are appended to s1)
char *strncpy(char *s1, const char *s2, size_t n) {
int size1, size2;
__infer_set_flag("ignore_return", ""); // no warnings if the return value is ignored
size1 = __get_array_size(s1);
size2 = __get_array_size(s2);
INFER_EXCLUDE_CONDITION(n > size1);
return s1;
}
// s1 and s2 must be allocated
// n should not be greater than the size of s1 or s2
// return a non-deterministic integer
int memcmp(const void *s1, const void *s2, size_t n) {
int size_s1;
int size_s2;
size_s1 = __get_array_size(s1);
size_s2 = __get_array_size(s2);
INFER_EXCLUDE_CONDITION((n>size_s1) || (n>size_s2));
return __infer_nondet_int();
}
// the strings s1 and s2 need to be allocated
// check that s2 fits inside s1
char *strcat(char *s1, const char *s2) {
int size1;
int size2;
size1 = __get_array_size(s1);
size2 = __get_array_size(s2);
INFER_EXCLUDE_CONDITION(size2>size1);
return s1;
}
// s1 and s2 must be allocated
// n should not be greater than the size of s1 or s2
// return s1
char *strncat(char *s1, const char *s2, size_t n) {
int size_s1;
int size_s2;
size_s1 = __get_array_size(s1);
size_s2 = __get_array_size(s2);
INFER_EXCLUDE_CONDITION((n>size_s1) || (n>size_s2));
return s1;
}
// s1 and s2 must be allocated
// n should not be greater than the size of s1 or s2
// return a non-deterministic integer
int memcmp(const void* s1, const void* s2, size_t n) {
int size_s1;
int size_s2;
__require_allocated_array(s1);
size_s1 = __get_array_length(s1);
__require_allocated_array(s2);
size_s2 = __get_array_length(s2);
INFER_EXCLUDE_CONDITION((n > size_s1) || (n > size_s2));
return __infer_nondet_int();
}
// the strings s1 and s2 need to be allocated
// check that n characters fit in s1 (because even if s2 is shorter than n, null
// characters are appended to s1)
char* strncpy(char* s1, const char* s2, size_t n) {
int size1;
__infer_set_flag("ignore_return",
""); // no warnings if the return value is ignored
__require_allocated_array(s1);
size1 = __get_array_length(s1);
__require_allocated_array(s2);
INFER_EXCLUDE_CONDITION(n > size1);
return s1;
}
// s1 and s2 must be allocated
// n should not be greater than the size of s1 or s2
// return s1
char* strncat(char* s1, const char* s2, size_t n) {
int size_s1;
int size_s2;
__require_allocated_array(s1);
size_s1 = __get_array_length(s1);
__require_allocated_array(s2);
size_s2 = __get_array_length(s2);
INFER_EXCLUDE_CONDITION((n > size_s1) || (n > size_s2));
return s1;
}
// the strings s1 and s2 need to be allocated
// check that s2 fits inside s1
char* strcat(char* s1, const char* s2) {
int size1;
int size2;
__require_allocated_array(s1);
size1 = __get_array_length(s1);
__require_allocated_array(s2);
size2 = __get_array_length(s2);
INFER_EXCLUDE_CONDITION(size2 > size1);
return s1;
}
// s1 and s2 must be allocated.
// return an integer between 0 ans the size of s1
size_t strspn(const char* s1, const char* s2) {
int size_s1;
int res;
res = __infer_nondet_int();
__require_allocated_array(s1);
size_s1 = __get_array_size(s1);
__require_allocated_array(s2);
INFER_EXCLUDE_CONDITION(res < 0 || res > size_s1);
return res;
}
// s1 and s2 must be allocated
// n must be between 0 and the minumum of the sizes of s1 and s2
void *memcpy(void *s1, const void *s2, size_t n) {
int size_s1;
int size_s2;
__infer_set_flag("ignore_return", ""); // no warnings if the return value is ignored
size_s1 = __get_array_size(s1);
size_s2 = __get_array_size(s2);
INFER_EXCLUDE_CONDITION((n < 0) || (n>size_s1) || (n>size_s2));
return s1;
}
// s1 and s2 must be allocated
// n should not be greater than the size of s1 or s2
// return a non-deterministic integer
int strncmp(const char *s1, const char *s2, size_t n) {
int size_s1;
int size_s2;
int res;
res = __infer_nondet_int();
size_s1 = __get_array_size(s1);
size_s2 = __get_array_size(s2);
INFER_EXCLUDE_CONDITION((n>size_s1) || (n>size_s2));
return res;
}
// s1 and s2 must be allocated
// n should not be greater than the size of s1 or s2
// return a non-deterministic integer
int strncmp(const char* s1, const char* s2, size_t n) {
int size_s1;
int size_s2;
int res;
res = __infer_nondet_int();
__require_allocated_array(s1);
size_s1 = __get_array_length(s1);
__require_allocated_array(s2);
size_s2 = __get_array_length(s2);
INFER_EXCLUDE_CONDITION((n > size_s1) || (n > size_s2));
return res;
}
// the string s must be allocated
// nondeterministically return 0 or a pointer inside the buffer
char *strchr(const char *s, int c) {
int size;
int nondet;
int offset;
nondet = __infer_nondet_int();
offset = __infer_nondet_int();
size = __get_array_size(s);
if(nondet) return 0;
INFER_EXCLUDE_CONDITION(offset < 0 || offset >=size);
return (void *)s + offset;
}
void* memchr(const void* s, int c, size_t n) {
#else
const void* memchr(const void* s, int c, size_t n) throw() {
return memchr((void*)s, c, n);
}
void* memchr(void* s, int c, size_t n) throw() {
#endif
int size;
int nondet;
int offset;
nondet = __infer_nondet_int();
offset = __infer_nondet_int();
__require_allocated_array(s);
size = __get_array_size(s);
INFER_EXCLUDE_CONDITION(n > size);
if (nondet)
return 0;
INFER_EXCLUDE_CONDITION(offset < 0 || offset >= n);
return (char*)s + offset;
}
// return NULL, or if s is NULL return a global variable, otherwise check that s has size at least L_tmpnam and return s
char *tmpnam(char *s) {
int success;
int size;
success = __infer_nondet_int();
if(!success) return NULL;
if(s) {
size = __get_array_size(s);
INFER_EXCLUDE_CONDITION(size < L_tmpnam);
return s;
}
else return _tmpnam_global;
}
void* memchr(const void* s, int c, size_t n) {
#else
// This overload is commented out on purpose. Look at strchr() for more info.
// const void* memchr(const void* s, int c, size_t n) throw() {
// return memchr((void*)s, c, n);
//}
void* memchr(void* s, int c, size_t n) throw() {
#endif
int size;
int nondet;
int offset;
nondet = __infer_nondet_int();
offset = __infer_nondet_int();
__require_allocated_array(s);
size = __get_array_length(s);
INFER_EXCLUDE_CONDITION(n > size);
if (nondet)
return 0;
INFER_EXCLUDE_CONDITION(offset < 0 || offset >= n);
return (char*)s + offset;
}
// the strings s1 and s2 must be allocated
// nondeterministically return 0 or a pointer inside the string s1
char *strstr(const char *s1, const char *s2) {
int size1, size2;
int nondet;
int offset;
nondet = __infer_nondet_int();
offset = __infer_nondet_int();
size1 = __get_array_size(s1);
size2 = __get_array_size(s2);
if(nondet) return 0;
INFER_EXCLUDE_CONDITION(offset < 0 || offset >=size1);
return (void *)s1 + offset;
}
// return NULL, or if s is NULL return a global variable, otherwise check that s
// has size at least L_tmpnam and return s
char* tmpnam(char* s) {
int success;
int size;
success = __infer_nondet_int();
if (!success)
return NULL;
if (s) {
__require_allocated_array(s);
size = __get_array_length(s);
INFER_EXCLUDE_CONDITION(size < L_tmpnam);
return s;
} else
return _tmpnam_global;
}
char* strchr(const char* s, int c) {
#else
const char* strchr(const char* s, int c) throw() { return strchr((char*)s, c); }
char* strchr(char* s, int c) throw() {
#endif
int size;
int nondet;
int offset;
nondet = __infer_nondet_int();
offset = __infer_nondet_int();
__require_allocated_array(s);
size = __get_array_size(s);
if (nondet)
return 0;
INFER_EXCLUDE_CONDITION(offset < 0 || offset >= size);
return (char*)s + offset;
}
char* strpbrk(const char* s1, const char* s2) {
#else
const char* strpbrk(const char* s1, const char* s2) throw() {
return strpbrk((char*)s1, s2);
}
char* strpbrk(char* s1, const char* s2) throw() {
#endif
int size1;
int nondet;
int offset;
nondet = __infer_nondet_int();
offset = __infer_nondet_int();
__require_allocated_array(s1);
size1 = __get_array_size(s1);
__require_allocated_array(s2);
if (nondet)
return 0;
INFER_EXCLUDE_CONDITION(offset < 0 || offset >= size1);
return (char*)s1 + offset;
}
char* strstr(const char* s1, const char* s2) {
#else
// This overload is commented out on purpose. Look at strchr() for more info.
/*const char* strstr(const char* s1, const char* s2) throw() {
return strstr((char*)s1, s2);
}*/
char* strstr(char* s1, const char* s2) throw() {
#endif
int size1, size2;
int nondet;
int offset;
nondet = __infer_nondet_int();
offset = __infer_nondet_int();
__require_allocated_array(s1);
size1 = __get_array_length(s1);
__require_allocated_array(s2);
if (nondet)
return 0;
INFER_EXCLUDE_CONDITION(offset < 0 || offset >= size1);
return (char*)s1 + offset;
}
// modelled using malloc
char* XGetAtomName(void* display, void* atom) {
int size;
INFER_EXCLUDE_CONDITION(size <= 0);
return (char*)malloc(size);
}
// modelled as free, requires NONNULL pointer
void XFree(void* ptr) {
INFER_EXCLUDE_CONDITION(!ptr);
free(ptr);
}
