file_content
stringlengths 65
76k
| goals
int64 1
283
|
|---|---|
/*@ predicate sorted{L}(long *t, integer a, integer b) =
@ \forall integer i,j; a <= i <= j <= b ==> t[i] <= t[j];
@*/
/*@ requires n >= 0 && \valid_range(t,0,n-1);
@ ensures -1 <= \result < n;
@ behavior success:
@ ensures \result >= 0 ==> t[\result] == v;
@ behavior failure:
@ assumes sorted(t,0,n-1);
@ ensures \result == -1 ==>
@ \forall integer k; 0 <= k < n ==> t[k] != v;
@*/
int binary_search(long t[], int n, long v) {
int l = 0, u = n-1;
/*@ loop invariant
@ 0 <= l && u <= n-1;
@ for failure:
@ loop invariant
@ \forall integer k; 0 <= k < n && t[k] == v ==> l <= k <= u;
@ loop variant u-l;
@*/
while (l <= u ) {
int m = (l + u) / 2;
//@ assert l <= m <= u;
if (t[m] < v) l = m + 1;
else if (t[m] > v) u = m - 1;
else return m;
}
return -1;
}
| 13
|
//@ predicate is_pos(int x) = x > 0;
//@ predicate is_nat(int x) = x >= 0;
/*@ requires is_pos(x);
ensures is_nat(\result);
*/
int minus1(int x) {
return x-1;
}
| 4
|
/*@
requires \valid(p);
requires \valid(q);
behavior p_changed:
assumes n >0;
assigns *p;
ensures *p == n;
behavior q_changed:
assumes n <= 0;
assigns *q;
ensures *q == n;
*/
void f(int n, int *p, int *q)
{
if (n > 0) *p = n; else *q = n;
}
| 10
|
/* run.config
DONTRUN: linked with first which is the real test.
*/
/*@ behavior b:
requires \valid(second);
ensures \result == 0;*/
int bar(int *second);
void sub (char * c) {
bar(c);
}
| 10
|
// This program used an advanced ACSL clause: \max()
// Note: Some versions of 'wp' plugin may not support the \lambda clause.
// The program may not verify in every machine.
/*@
requires n > 0;
requires \valid_read(arr+(0..n-1));
ensures \result == \max(0, n-1, \lambda integer i; arr[i]);
assigns \nothing;
*/
int array_max_advanced(int* arr, int n) {
int max = arr[0];
for (int i = 0; i < n; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
| 10
|
/*@ requires a_valid: \valid(a);
requires b_valid: \valid(b);
assigns *a, *b;
ensures a_value: *a == \at(*b,Pre);
ensures b_value: *b == \at(*a, Pre);
*/
void swap(int* a, int *b);
/*@ requires a_valid: \valid(a);
requires b_valid: \valid(b);
requires c_valid: \valid(c);
requires sep: \separated(a,b,c);
ensures a_value: *a == \at(*b, Pre);
ensures b_value: *b == \at(*c, Pre);
ensures c_value: *c == \at(*a, Pre);
*/
void permut(int* a, int *b, int *c) {
swap(a,b);
swap(b,c);
}
| 9
|
/*@
requires \valid(p);
ensures \result == *p;
*/
int foo(int* p) {
return *p;
}
| 4
|
/*
Software versions:
frama-c : 18.0 (Argon)
alt-ergo : 2.2.0
This script was run using this command:
frama-c -wp -wp-prover alt-ergo -wp-rte -wp-timeout 300 -wp-verbose 0 countSameConsecutive.c -then -report
*/
// This predicate is true if there is a subsequence of length "answer"
// with all its elements equal.
/*@ predicate isValidAnswer(integer N, int *x, int answer) =
@ \exists integer i; 0 <= i <= N-answer &&
@ (\forall integer j; i <= j <= i+answer-1 ==> x[j] == x[i]);
@*/
// This predicate is true if there is no subsequence of length "answer+1"
// with all its elements equal.
/*@
@ predicate noBetterAnswerExists(integer N, int *x, int answer) =
@ (N == answer) ||
@ ((1 <= answer < N) && (\forall integer i; 0 <= i <= N-1-answer ==>
@ (\exists integer j; i < j <= i+answer && x[j] != x[i])));
@*/
/*@
@ predicate isBest(integer N, int *x, int answer) =
@ isValidAnswer(N, x, answer) &&
@ noBetterAnswerExists(N, x, answer);
@*/
/*@ requires 1 <= N <= 1000000;
@ requires \valid(x + (0 .. N-1));
@ assigns \nothing;
@ ensures isBest(N, x, \result);
@*/
int countSameConsecutive(int N, int x[]) {
int best = 0, i = 0;
/*@ loop invariant 0 <= i <= N;
@ loop invariant i == 0 ==> best == 0;
@ loop invariant 0 < i <= N ==> isBest(i, x, best);
@ loop invariant 0 < i < N ==> x[i] != x[i-1];
@ loop assigns i, best;
@ loop variant N-i;
@*/
while (i < N) {
int j = i+1;
/*@ loop invariant i+1 <= j <= N;
@ loop invariant \forall integer k; i+1 <= k < j ==> x[i] == x[k];
@ loop assigns j;
@ loop variant N-j;
@*/
while (j < N && x[j] == x[i]) ++j;
if (j-i > best) best = j-i;
i = j;
}
return best;
}
| 31
|
/*@predicate who_is_taller{L}(int *x,integer j, integer last)=
@ \forall integer i; j < i < last ==> x[j] > x[i];
@
*/
/*@ predicate how_many{L}(int *x, integer counter, integer size,integer cnt) =
@ (counter < size) ?
@ (who_is_taller(x,counter,size))? how_many(x,counter+1,size,cnt-1)
@ : how_many(x,counter+1,size,cnt)
@ : cnt == 0;
@*/
/*@ requires 0< N <= 1000000 ;
@ requires \valid(x+(0..N-1));
@ requires \forall integer i;
0 <= i <= N-1 ==> 0< x[i] <= 1000000;
@ ensures how_many(x,0,N,\result);
@*/
int countWhoCanSee (int N, int x[])
{
int tallest = x[N-1];
int count = 1;
/*@ loop invariant -1 <= i < N-1;
@ loop invariant 1 <= count < N-i;
@ loop invariant \exists integer j;
@ i<j<N && tallest==x[j];
@ loop invariant \forall integer j;
@ i<j<N ==> tallest >=x[j];
@ loop invariant how_many(x,i+1,N,count);
@ loop assigns i,count,tallest;
@ loop variant i;
@*/
for (int i = N-2; i >= 0; i--)
if (tallest < x[i]) {
tallest = x[i];
count++;
}
return count;
}
| 23
|
/*@
@ requires
@ \valid(t + (0..size - 1)) &&
@ 0 <= i < size &&
@ 0 <= j < size;
@
@ ensures
@ \forall integer k;
@ 0 <= k < size && k != i && k != j ==>
@ t[k] == \old(t[k]);
@
@ ensures
@ t[i] == \old(t[j]) &&
@ t[j] == \old(t[i]);
@
@ assigns
@ t[i], t[j];
@
@*/
void swap(int t[], int size, int i, int j) {
int tmp = t[i];
t[i] = t[j];
t[j] = tmp;
}
| 10
|
/*@ensures\result == a &&\result>b
|| \result>a &&\result == b
|| \result == a &&\result == b;*/
int max(int a, int b)
{return a>b ? a : b;}
| 3
|
#include <stddef.h>
#include <stdio.h>
/*@
predicate valid_range_rw(int* arr, integer n) =
n >= 0 && \valid(arr + (0 .. n-1));
predicate valid_range_r(int* arr, integer n) =
n >= 0 && \valid_read(arr + (0 .. n-1));
predicate sorted(int* arr, integer n) =
\forall integer i, j; 0 <= i <= j < n ==> arr[i] <= arr[j];
predicate contains(int* arr, integer n, integer elem) =
\exists integer off; 0 <= off < n && arr[off] == elem;
*/
/*@
requires valid_range_r(arr, len);
requires sorted(arr, len);
assigns \nothing;
behavior in:
assumes contains(arr, len, value);
ensures arr[\result] == value;
ensures 0 <= \result <= len-1;
behavior notin:
assumes !contains(arr, len, value);
ensures \result == -1;
disjoint behaviors;
complete behaviors;
*/
int bsearch(int* arr, int len, int value){
if(len == 0) return -1 ;
int low = 0 ;
int up = len-1 ;
/*@
loop invariant 0 <= low && up <= len-1;
loop invariant \forall integer i; 0 <= i < low ==> arr[i] != value;
loop invariant \forall integer i; up < i <= len-1 ==> arr[i] != value;
loop assigns low, up;
loop variant up - low;
*/
while(low <= up){
int mid = low + (up - low)/2 ;
if (arr[mid] > value) up = mid-1 ;
else if(arr[mid] < value) low = mid+1 ;
else return mid ;
}
return -1 ;
}
int main(){
int i;
int a[] = {1,2,3,4,5,6,7,8,9,10};
i = bsearch(a, 10, 3);
//@ assert i == 2;
i = bsearch(a, 10, 0);
//@ assert i == -1;
//printf("i = %d\n", i);
return 0;
}
| 37
|
#include <string.h>
/*@
requires strlen(input)>=0 && \valid(input+(0..strlen(input)));
assigns \nothing;
ensures \result==0 || \result==1;
*/
int dfa_aab(char* input) {
if (*input == '\0') return 0/*false*/;
int id = 0;
char c;
/*@
loop invariant strlen(input)>0 && \valid(input+(0..strlen(input)));
loop invariant id == 6 || id == 3 || id == 0;
loop assigns id, c, input;
loop variant strlen(input);
*/
while (input[1] != '\0') {
c = *input++;
if (id == 0) {
char x1 = c;
int x2 = x1 == 'A';
int x16;
if (x2) {
x16 = 3;
} else {
x16 = 0;
}
id = x16;
}
else if (id == 6) {
char x7 = c;
int x8 = x7 == 'A';
int x13;
if (x8) {
x13 = 6;
} else {
x13 = 0;
}
id = x13;
}
else if (id == 3) {
char x4 = c;
int x5 = x4 == 'A';
int x14;
if (x5) {
x14 = 6;
} else {
x14 = 0;
}
id = x14;
}
else { return -1; /*error: invalid state*/ }
}
c = *input;
if (id == 0) {
char x1 = c;
int x2 = x1 == 'A';
int x16;
if (x2) {
x16 = 0/*false*/;
} else {
x16 = 0/*false*/;
}
id = x16;
}
else if (id == 6) {
char x7 = c;
int x8 = x7 == 'A';
int x13;
if (x8) {
x13 = 0/*false*/;
} else {
x13 = 1/*true*/;
}
id = x13;
}
else if (id == 3) {
char x4 = c;
int x5 = x4 == 'A';
int x14;
if (x5) {
x14 = 0/*false*/;
} else {
x14 = 0/*false*/;
}
id = x14;
}
else { return -1; /*error: invalid state */ }
return id;
}
| 39
|
/* @ requires \valid(t+(start..end)) && start <= i <= end && start <= j <= end
*/
void swap(int t[], int i, int j, int start, int end) {
int tmp = t[i];
t[i] = t[j];
t[j] = tmp;
}
/*@ requires 0 <= p <= r && \valid(A+(p..r)); @*/
int partition (int A[], int p, int r)
{
int x = A[r];
int j, i = p-1;
/*@ loop invariant p <= j <= r && p-1 <= i < j;
@ loop assigns i, j, A[p..r];
@ loop variant r-j;
@*/
for (j=p; j<r; j++)
if (A[j] <= x) {
i++;
swap(A, i, j, p, r);
}
swap(A,i+1,r,p,r);
return i+1;
}
| 39
|
#define HASHTBL_LEN 17
typedef struct {
int b;
int size;
} Buckets;
typedef struct {
Buckets data[HASHTBL_LEN];
int size;
} Hashtbl;
/*@ requires \valid(tbl);
@ requires \valid(tbl->data+(0 .. HASHTBL_LEN - 1));
@ requires 0 <= d < HASHTBL_LEN;
@
@ assigns tbl->data[d], tbl->size; // approximation sur tbl->data[d]; si on écrit tbl->data[d].size, pas de problème
@ */
int add(Hashtbl *tbl, int d) {
unsigned int h = d;
tbl->data[h].size = 0; // si on inline d, pas de probleme
tbl->size = 0;
return 0;
}
| 8
|
#include<stdio.h>
#include<limits.h>
/*@ requires x>=0;
ensures \result == x*x*x; */
int p2(int x){
int z=0,v=0,w=1,t=3,u=0;
/*@ loop invariant u<=x && t==6*u+3 && w==3*u+1 && v==3*u*u && z==u*u*u;
loop assigns z,v,t,w,u;*/
while ( u <= x ){
z=z+v+w;
v=v+t ;
t = t+6;
w=w+3;
u=u+1;
}
//@ assert u==x;
//@ assert z==x*x*x;
return ( z ) ;
}
int main (){
int v,r;
printf("Entrez la valeur pour v : " );
scanf ("%d",&v);
r=v*v*v;
printf( "voici la réponse de votre solution p2(%d)=%d et devrait valeur %d\n ",v,p2(v),r);
return 0 ;
}
| 8
|
// Version 2: Better specification
#include <limits.h>
/*@ requires x > INT_MIN;
behavior positive:
assumes x > 0;
ensures \result == \old(x);
behavior negative:
assumes x < 0;
ensures \result == \old(-x);
*/
int abs(int x) {
if (x < 0)
return -x;
else
return x;
}
int main() {
abs(10);
abs(-20);
return 0;
}
| 9
|
/*@
requires \valid(a) && \valid_read(b);
requires \separated(a, b);
assigns *a;
ensures *a == \old(*a) + *b;
ensures *b == \old(*b);
*/
int incr_a_by_b(int* a, int const* b){
*a += *b;
return *a;
}
| 9
|
/*@
requires n>0;
requires\valid_read(arr + (0..n-1));
*/
void cummilativeSum(int arr[], int n)
{
int sum = 0, prev = 0, j, x;
/*@
loop invariant \exists integer i; 0 <= i < n ==> arr[j] == prev + arr[i];
loop invariant 0 <= j <= n;
loop assigns j, arr[0..j+1], prev;
loop variant n-j;
*/
for (j = 0; j < n; j++)
{
arr[j] = prev + arr[j];
prev = arr[j];
}
}
| 9
|
/*@ predicate sorted{L}(int* a, integer length) =
\forall integer i,j; 0<=i<=j<length ==> a[i]<=a[j];
*/
/*@ requires \valid(a+(0..length-1));
requires length > 0;
assigns a[0..length-1];
ensures sorted(a,length);
*/
void sort (int* a, int length) {
int current;
/*@ loop invariant 0<=current<length;
loop assigns a[0..length-1],current;
loop invariant sorted(a,current);
loop invariant
\forall integer i,j; 0<=i<current<=j<length ==> a[i] <= a[j];
loop variant length-current;
*/
for (current = 0; current < length - 1; current++) {
int min_idx = current;
int min = a[current];
/*@ loop invariant current+1<=i<=length;
loop assigns i,min,min_idx;
loop invariant current<=min_idx<i;
loop invariant a[min_idx] == min;
loop invariant
\forall integer j; current<=j<i ==> min <= a[j];
loop variant length -i;
*/
for (int i = current + 1; i < length; i++) {
if (a[i] < min) {
min = a[i];
min_idx = i;
}
}
if(min_idx != current) {
L: a[min_idx]=a[current];
a[current]=min;
}
}
}
| 39
|
/*@
requires a!=0;
ensures \result == 1;
assigns \nothing;
*/
int func(int a) {
int x, y;
int sum, res;
if (a == 0){
x = 0; y = 0;
}
else {
x = 5; y = 5;
}
sum = x + y;
res = 10/sum;
return res;
}
| 12
|
/*@ requires \true;
assigns \nothing;
ensures \result == b;
*/
int deadcode(int a, int b)
{
if (a > b) {
if (a < b) {
return a / b;
} else if (a == b) {
//@ assert 0 == 1;
}
}
return b;
}
| 8
|
#include<limits.h>
/*@ ensures \result >= a && \result >= b; */
int max ( int a, int b ) {
return INT_MAX ;
}
| 3
|
/*@
@ assigns \nothing;
@ ensures \result <= a;
@ ensures \result <= b;
@ ensures \result == a || \result == b;
*/
int min(int a, int b) {
return (a < b) ? a : b;
}
| 7
|
#include <stddef.h>
/*@ predicate monotone_slice(int* a, size_t low, size_t up) =
(\forall integer i,j; low <= i < j < up ==> a[i] < a[j]) ||
(\forall integer i,j; low <= i <= j < up ==> a[i] >= a[j]);
*/
/*@
requires length < 100;
requires a_valid: \valid(a + (0 .. length - 1));
requires res_valid: \valid(cutpoints + (0 .. length));
requires sep: \separated(a + (0 .. length - 1), cutpoints + (0 .. length));
assigns cutpoints[0 .. length];
ensures pos: \result > 0;
ensures beg: cutpoints[0] == 0;
ensures end: cutpoints[\result - 1] == length;
ensures bounds: \forall integer i; 0 <= i < \result ==>
0<= cutpoints[i] <= length;
ensures monotonic:
\forall integer i; 0 <= i < \result - 1 ==>
monotone_slice(a,cutpoints[i],cutpoints[i+1]);
*/
size_t monotonic(int* a, size_t length, size_t* cutpoints) {
cutpoints[0] = 0;
if (length == 0) return 1;
size_t x = 0, y = 1;
size_t res = 1;
/*@
loop invariant outer_bound: 1 <= y <= length;
loop invariant x_1: y < length ==> x == y - 1;
loop invariant x_2: y == length ==> x == y - 1 || x == y;
loop invariant monotone:
\forall integer i; 0 <= i < res - 1 ==>
monotone_slice(a,cutpoints[i],cutpoints[i+1]);
loop invariant res_bounds: 1 <= res <= y;
loop invariant content_bounds:
\forall integer i; 0 <= i < res ==> 0<= cutpoints[i] <= length;
loop invariant cuts_increase:
\forall integer i, j; 0 <= i <= j < res ==> cutpoints[i] <= cutpoints[j];
loop invariant last_write: cutpoints[res - 1] == x;
loop assigns x,y,res,cutpoints[1 .. length];
loop variant length - y;
*/
while (y < length) {
int increasing = a[x] < a[y];
/*@
loop invariant inner_bound: x + 1 <= y <= length;
loop invariant res_low: res <= y;
loop invariant mono_slice_1:
increasing ==> \forall integer i, j; x <= i < j < y ==> a[i] < a[j];
loop invariant mono_slice_2:
(!increasing) ==> \forall integer i, j; x <= i <= j < y ==> a[i] >= a[j];
loop assigns y;
loop variant length - y;
*/
while (y < length && (a[y-1] < a[y]) == increasing) y++;
/*@ assert mono: monotone_slice(a,x,y); */
cutpoints[res] = y;
res++;
/*@ assert mono_res: monotone_slice(a,cutpoints[res-2],cutpoints[res-1]);*/
x = y;
if (y < length) y++;
}
if (x < length) {
/*@ assert last: x == length - 1; */
/*@ assert mono_2: monotone_slice(a,x,length); */
cutpoints[res] = length;
res++;
/*@ assert mono_3: monotone_slice(a,cutpoints[res - 2], cutpoints[res - 1]); */
}
return res;
}
| 57
|
/*@
requires \valid(a) && \valid(b);
assigns *a, *b;
ensures (*a) == \old(*b);
ensures (*b) == \old(*a);
*/
void foo(int* a, int* b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
| 10
|
/*@requires a>0 && a<2147483647;
ensures\result>1;*/
int next(int a)
{return a + 1;}
| 4
|
/*@
predicate swapped {L1, L2}(int* a, int* b) =
\at(*a, L1) == \at(*b, L2) &&
\at(*b, L1) == \at(*a, L2);
*/
/*@
requires \valid(a);
requires \valid(b);
assigns *a;
assigns *b;
ensures *a == \old(*b);
ensures *b == \old(*a);
ensures swapped{Here, Old}(a,b);
*/
void swap (int* a, int* b )
{
int c = *a;
*a = *b;
*b = c;
}
| 11
|
#include <stdio.h>
/*@
requires \valid(a+(0..n-1));
requires n > 0;
ensures \forall integer i,j; 0<=i<=j<=n-1 ==> a[i]<=a[j];
*/
void bubbleSort(int *a, int n) {
int i, j, temp;
/*@
loop invariant \forall integer p,q; i<=p<=q<=n-1 ==> a[p]<=a[q];
loop invariant \forall integer p,q; 0<=p<i+1==q<=n-1 ==> a[p]<=a[q];
loop invariant 0<=i<n;
loop assigns i,j,temp,a[0..n-1];
loop variant i;
*/
for(i=n-1; i>0; i--) {
/*@ loop invariant 0<=j<=i<n;
loop invariant \forall integer k; 0<=k<=j ==> a[k] <= a[j];
loop invariant \forall integer p, q; 0<=p<i+1==q<=n-1 ==> a[p]<=a[q];
loop assigns j,temp,a[0..i];
loop variant i-j;
*/
for(j=0; j<i; j++) {
if (a[j] > a[j+1]) {
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}
| 38
|
/*
* Frama-C version: Sulfur-20171101
* Alt-Ergo version: 1.30
*
* Run with:
* frama-c -wp -wp-prover alt-ergo -wp-rte -wp-timeout 10 -wp-verbose 0 find-double.c -then -report
*
*/
#include <stdbool.h>
#define MAXV 1000000
/*@ predicate doublesInside(integer N, int* a, integer res) =
@ \exists integer ii; \exists integer jj;
@ 0 <= ii < N && 0 <= jj < N && ii != jj ==> a[ii] == a[jj] == res;
@*/
/*@ predicate noDoublesInside(integer N, int* a) =
@ \forall integer ii; \forall integer jj;
@ 0 <= ii < N && 0 <= jj < N && ii != jj ==> a[ii] != a[jj];
@*/
/*@ predicate doublesFound(integer N, int* a, integer res) =
@ (res > 0) ? doublesInside(N, a, res) : noDoublesInside(N, a);
@*/
/*@ requires 1 <= N <= MAXV;
@ requires \valid(a + (0..N-1));
@ requires \forall integer p; 0 <= p < N ==> 1 <= a[p] <= MAXV;
@ ensures doublesFound(N, a, \result);
@*/
int findDouble(int N, int a[]) {
bool f[MAXV];
/*@ loop invariant 1 <= i <= MAXV+1;
@ loop invariant \forall integer p; 1 <= p < i ==> f[p-1] == false;
@ loop assigns i, f[0..(MAXV-1)];
@ loop variant MAXV - i;
@*/
for (int i = 1; i <= MAXV; ++i) f[i-1] = false;
/*@ loop invariant 0 <= i <= N;
@ loop invariant \forall integer p; 0 <= p < i ==> f[a[p]-1] != false;
@ loop invariant noDoublesInside(i, a);
@ loop assigns i, f[0..(MAXV-1)];
@ loop variant N - i;
@*/
for (int i = 0; i < N; ++i)
if (f[a[i]-1]) return a[i]; else f[a[i]-1] = true;
return 0;
}
| 34
|
/*@ requires size >= 0;
requires \valid(a+(0..size-1));
requires \valid(res+(0..size-1));
assigns res[0..size-1];
ensures \forall integer i; 0 <= i < size ==> res[i] == a[size - i - 1];
*/
void reverse(int a[], int res[], int size)
{
int i;
/*@ loop invariant -1 <= i < size; //Найдите ошибку
loop invariant \forall integer j; i < j < size ==> res[j] == a[size - j - 1];
loop assigns i, res[0..size-1];
loop variant i;
*/
for(i = size - 1; i >= 0; --i) {
res[i] = a[size - i - 1];
}
}
#ifdef OUT_OF_TASK
#include <stdio.h>
int main(void)
{
int a[] = {1,2,3,4,5,6,7,8,9,10};
int size = sizeof(a) / sizeof(a[0]);
int b[size];
for(int i = 0; i < size; ++i) {
printf("%d ", a[i]);
}
printf("\n");
reverse(a, b, size);
for(int i = 0; i < size; ++i) {
printf("%d ", b[i]);
}
printf("\n");
}
#endif
| 20
|
/*@ predicate Swap{L1,L2}(int *a, integer i, integer j) =
@ \at(a[i],L1) == \at(a[j],L2) &&
@ \at(a[j],L1) == \at(a[i],L2) ;
@*/
/*@ inductive Permuta{L1,L2}(int *a, integer l, integer h) {
@ case Permut_refl{L}:
@ \forall int *a, integer l, h; Permuta{L,L}(a, l, h) ;
@ case Permut_sym{L1,L2}:
@ \forall int *a, integer l, h;
@ Permuta{L1,L2}(a, l, h) ==> Permuta{L2,L1}(a, l, h) ;
@ case Permut_trans{L1,L2,L3}:
@ \forall int *a, integer l, h;
@ Permuta{L1,L2}(a, l, h) && Permuta{L2,L3}(a, l, h) ==>
@ Permuta{L1,L3}(a, l, h) ;
@ case Permut_swap{L1,L2}:
@ \forall int *a, integer l, h, i, j;
@ l <= i <= h && l <= j <= h && Swap{L1,L2}(a, i, j) ==>
@ Permuta{L1,L2}(a, l, h) ;
@ }
@*/
/*@ requires \valid(t+(start..end)) && start <= i <= end && start <= j <= end;
@ ensures Swap{Old,Here}(t,i,j);
@ assigns t[i],t[j];
@*/
void swap(int t[],int i,int j, int start, int end) {
int tmp = t[i];
t[i] = t[j];
t[j] = tmp;
}
/*@ requires 0 <= p <= r && \valid(A+(p..r));
@ assigns A[p..r];
@ behavior partition:
@ ensures
@ p <= \result <= r &&
@ (\forall int l; p <= l < \result ==> A[l] <= A[\result]) &&
@ (\forall int l; \result < l <= r ==> A[l] > A[\result]) &&
@ A[\result] == \old(A[r]) ;
@ behavior permutation:
@ ensures
@ Permuta{Old,Here}(A,p,r);
@*/
int partition (int A[], int p, int r)
{
int x = A[r];
int j, i = p-1;
/*@ loop invariant
@ p <= j <= r && p-1 <= i < j;
@ loop assigns i, j, A[p..r-1];
@ for partition:
@ loop invariant
@ (\forall int k; (p <= k <= i) ==> A[k] <= x) &&
@ (\forall int k; (i < k < j) ==> A[k] > x) &&
@ A[r] == x;
@ for permutation:
@ loop invariant
@ Permuta{Pre,Here}(A,p,r);
@ loop variant (r-j);
@*/
for (j=p; j<r; j++)
if (A[j] <= x) {
i++;
swap(A,i,j,p,r);
}
swap(A,i+1,r,p,r);
return i+1;
}
| 42
|
/*@ assigns \nothing;
ensures \result == (a+b)/2;
*/
int average(int a, int b)
{
int average = 0;
int greater;
int smaller;
if (a > b) {
greater = a;
smaller = b;
} else {
greater = b;
smaller = a;
}
if (a >= 0 && b >= 0) {
average = smaller + (greater - smaller) / 2;
} else if (a < 0 && b < 0) {
average = greater + (smaller - greater) / 2;
} else if ((a >= 0 && b <= 0) || (a <= 0 && b >= 0)) {
average = (a + b) / 2;
}
return average;
}
#ifdef OUT_OF_TASK
#include <stdio.h>
int main(void)
{
printf("res: %d\n", average(3,30));
printf("res: %d\n", average(-5,-20));
printf("res: %d\n", average(7,-10));
printf("res: %d\n", average(-2,15));
return 0;
}
#endif
| 20
|
#define INT_MIN (-2147483648)
#define INT_MAX 2147483647
/*@ requires INT_MIN <= a + b <= INT_MAX;
assigns \nothing;
ensures \result == a + b;
*/
int sum(int a, int b)
{
return a + b;
}
| 6
|
#include <limits.h>
struct A
{
unsigned int size;
unsigned int pos;
};
typedef struct A A;
/*@
requires \valid(a);
requires length <= 64;
requires a->pos + length <= UINT_MAX;
requires a->pos + length <= a->size;
assigns a->pos;
ensures a->pos == \old(a->pos) + length;
*/
void foo(A* a, unsigned int length)
{
a->pos += length;
}
/*@
requires \valid(a);
requires length <= 64;
requires a->pos + length <= UINT_MAX;
requires a->pos + length <= a->size;
assigns a->pos;
ensures a->pos == \old(a->pos) + length;
*/
void bar(A* a, unsigned int length)
{
foo(a, length);
a->pos -= length;
foo(a, length);
}
| 25
|
/*@ requires \valid(&a[i]);
requires \valid(&a[j]);
assigns a[i], a[j];
ensures a[i] == \old(a[j]);
ensures a[j] == \old(a[i]);
*/
void swap(int a[], int i, int j)
#ifndef OUT_OF_TASK
;
#else
{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
#endif
/*@ predicate reverse{L1,L2}(int* a, integer size, integer i, integer j) =
\forall integer k; i <= k < j ==>
\at(a[k], L1) == \at(a[size - k - 1], L2);
predicate reverse{L1,L2}(int* a, integer size) = reverse{L1,L2}(a, size, 0, size);
*/
/*@ requires size >= 0;
requires \valid(a+(0..size-1));
assigns a[0..size-1];
ensures reverse{Pre,Here}(a, size);
ensures \forall integer i; 0 <= i < size ==>
\exists integer j; 0 <= j < size &&
\old(a[\at(i,Here)]) == a[j];
*/
void reverse_in_place(int a[], int size)
{
int i;
/*@ loop invariant 0 <= i <= size / 2;
loop invariant reverse{Pre,Here}(a, size, 0, i);
loop invariant \forall integer j; i <= j < size - i ==> a[j] == \at(a[\at(j,Here)],Pre);
loop invariant reverse{Pre,Here}(a, size, size - i, size);
loop assigns i, a[0..size-1];
loop variant size / 2 - i;
*/
for(i = 0; i < (size / 2); ++i) {
swap(a, i, size - i - 1);
}
}
#ifdef OUT_OF_TASK
#include <stdio.h>
int main(void)
{
int a[] = {1,2,3,4,5,6,7,8,9,10};
int size = sizeof(a) / sizeof(a[0]);
for(int i = 0; i < size; ++i) {
printf("%d ", a[i]);
}
printf("\n");
reverse_in_place(a, size);
for(int i = 0; i < size; ++i) {
printf("%d ", a[i]);
}
printf("\n");
}
#endif
| 28
|
/*@ assigns \nothing;
ensures \result >= a;
ensures \result >= b;
ensures \result == a || \result == b;
*/
int max(int a, int b)
{
return a > b ? a : b;
}
| 7
|
/*@
requires n>0;
behavior one:
assumes n>0;
ensures \result == n;
behavior two:
assumes n<0;
ensures \result == (-1)*n;
complete behaviors;
disjoint behaviors;
*/
int ABS(int n)
{
if (n < 0)
{
n = (-1) * n;
}
return n;
}
| 8
|
/*@ predicate sorted{L}(int* a, integer length) =
\forall integer i,j; 0<=i<=j<length ==> a[i]<=a[j];
*/
/*@ predicate swap{L1,L2}(int* a,integer i,integer j,integer length)=
0<=i<j<length
&& \at(a[i],L1) == \at(a[j],L2)
&& \at(a[i],L2) == \at(a[j],L1)
&& \forall integer k; 0<=k<length && k!=i && k!=j ==>
\at(a[k],L1) == \at(a[k],L2);
*/
/*@ inductive same_elements{L1,L2}(int*a , integer length) {
case refl{L}:
\forall int*a, integer length; same_elements{L,L}(a,length);
case swap{L1,L2}: \forall int*a, integer i,j,length;
swap{L1,L2}(a,i,j,length) ==> same_elements{L1,L2}(a,length);
case trans{L1,L2,L3}: \forall int*a, integer length;
same_elements{L1,L2}(a,length)
==> same_elements{L2,L3}(a,length)
==> same_elements{L1,L3}(a,length);
}
*/
/*@ requires valid_array: \valid(a+(0..length-1));
requires non_empty: length > 0;
assigns a[0..length-1];
behavior sorted:
ensures sorted(a,length);
behavior same_elements:
ensures same_elements{Pre,Here}(a,length);
*/
void sort (int* a, int length) {
int current;
/*@ loop invariant outer_bounds: 0<=current<length;
loop assigns a[0..length-1],current;
for sorted: loop invariant begin_sort: sorted(a,current);
for sorted: loop invariant tail_bigger:
\forall integer i,j; 0<=i<current<=j<length ==> a[i] <= a[j];
for same_elements: loop invariant
same_elements{Pre,Here}(a,length);
loop variant length-current;
*/
for (current = 0; current < length - 1; current++) {
int min_idx = current;
int min = a[current];
/*@ loop invariant inner_bounds: current+1<=i<=length;
loop assigns i,min,min_idx;
loop invariant min_idx_bounds: current<=min_idx<i;
loop invariant min_idx_val: a[min_idx] == min;
for sorted: loop invariant min_idx_min:
\forall integer j; current<=j<i ==> min <= a[j];
loop variant length -i;
*/
for (int i = current + 1; i < length; i++) {
if (a[i] < min) {
min = a[i];
min_idx = i;
}
}
if(min_idx != current) {
L: a[min_idx]=a[current];
a[current]=min;
/*@ for same_elements: assert swap:
swap{L,Here}(a,current,min_idx,length);
*/
}
}
}
| 43
|
// remplir un tableau avec une valeur donnée
/*@
requires \valid (t+(0..n-1));
requires n > 0;
assigns t[0..n-1];
ensures \forall integer i; 0 <= i < n ==> t[i] == val;
*/
void fill_array(int t[], int n, int val)
{
int i = 0;
/*@
loop invariant \forall integer j; 0 <= j < i ==> t[j] == val;
loop invariant 0 <= i <= n;
loop variant n-i;
*/
while (i < n)
{
t[i] = val;
i++;
}
}
| 43
|
#include <limits.h>
/*@
requires INT_MIN<x && INT_MIN<y;
ensures \result>=x && \result>=y;
ensures \result==x || \result==y;
*/
int max ( int x, int y ) {
if ( x >=y )
return x ;
return y ;
}
void foo()
{
int s = max(34,45);
int t = max(-43,34);
}
| 8
|
/* Run with:
*
* frama-c -wp -wp-prover alt-ergo -wp-rte -wp-timeout 60 -wp-verbose 0 samenum.c -then -report
*
* Tested with Frama-C Phosphorus-20170501.
*/
#define MAXN 1000000
#define MAXV 2000000
/*@ predicate isPair{L}(integer N, int* x, integer i, integer j) =
@ 0 <= i < j < N && \at(x[i], L) == \at(x[j], L);
@*/
/*@ predicate existsPair{L}(integer N, int* x) =
@ \exists integer i, j; 0 <= i < j < N && \at(x[i], L) == \at(x[j], L);
@*/
/*@ predicate isValidSolution{L}(integer N, int* x, integer r) =
@ existsPair{L}(N, x) ?
@ (\exists integer i, j; 0 <= i < j < N && \at(x[i], L) == \at(x[j], L) ==> r == j - i) &&
@ (\forall integer n, m; 0 <= n < m < N && \at(x[n], L) == \at(x[m], L) ==> r >= m - n)
@ : r == 0;
@*/
/*@ requires 0 <= N <= MAXN;
@ requires \valid(x + (0..N-1));
@ requires \forall integer j; 0 <= j < N ==> 0 <= x[j] <= MAXV;
@ ensures isValidSolution(N, x, \result);
@*/
int samenum(int N, int *x) {
int p[MAXV+1];
/*@ loop invariant 0 <= i <= MAXV+1;
@ loop invariant \forall integer j; 0 <= j < i ==> p[j] == -1;
@ loop assigns i, p[0 .. MAXV];
@ loop variant MAXV - i;
@*/
for (int i = 0; i <= MAXV; ++i) p[i] = -1;
int best = 0;
/*@ loop invariant 0 <= i <= N;
@ loop invariant \forall integer j; i <= j < N ==> p[x[j]] >= -1;
@ loop invariant \forall integer j; 0 <= j < i ==>
(best >= j - p[x[j]] || p[x[j]] == j);
@ loop invariant best >= 0;
@ loop invariant \forall integer j; 0 <= j <= MAXV && p[j] >= 0 <==>
(\exists integer k; 0 <= k < i && x[k] == j);
@ loop invariant \forall integer j, k; 0 <= k <= j < i && x[j] == x[k] ==>
p[x[j]] <= k;
@ loop invariant isValidSolution(i, x, best);
@ loop assigns i, best, p[0 .. MAXV];
@ loop variant N - i;
@*/
for (int i = 0; i < N; ++i) {
if (p[x[i]] == -1) p[x[i]] = i;
else if (i-p[x[i]] > best) best = i-p[x[i]];
}
return best;
}
| 47
|
/*@ requires \valid(&a[i]);
requires \valid(&a[j]);
assigns a[i], a[j];
ensures a[i] == \old(a[j]);
ensures a[j] == \old(a[i]);
*/
void swap(int a[], int i, int j);
/*@ predicate reverse{L1,L2}(int* a, integer size, integer i, integer j) =
\forall integer k; i <= k < j ==>
\at(a[k], L1) == \at(a[size - k - 1], L2);
predicate reverse{L1,L2}(int* a, integer size) = reverse{L1,L2}(a, size, 0, size);
*/
/*@ requires size >= 0;
requires \valid(a+(0..size-1));
assigns a[0..size-1];
ensures reverse{Pre,Here}(a, size);
ensures \forall integer i; 0 <= i < size ==>
\exists integer j; 0 <= j < size &&
\old(a[\at(i,Here)]) == a[j];
*/
void reverse_in_place(int a[], int size)
{
int i;
/*@ loop invariant 0 <= i <= size / 2;
loop invariant reverse{Pre,Here}(a, size, 0, i);
loop invariant \forall integer j; i <= j < size - i ==> a[j] == \at(a[\at(j,Here)],Pre);
loop invariant reverse{Pre,Here}(a, size, size - i, size);
loop assigns i, a[0..size-1];
loop variant size / 2 - i;
*/
for(i = 0; i < (size / 2); ++i) {
swap(a, i, size - i - 1);
}
}
| 28
|
#include <limits.h>
/*@ requires x < INT_MAX;
ensures \result > x;
*/
int inc (int x) { return x+1; }
| 4
|
#include <limits.h>
#include <string.h>
/*@ predicate star_A(char * x93, integer x94, integer x95) = ((x94==x95) || (\exists integer x98; (((x94<x98) &&
(x98<=x95)) ==> ((('A'==x93[x94]) &&
(x98==(x94+1))) &&
star_A(x93,x98,x95)))));*/
/*@ predicate star_D(char * x114, integer x115, integer x116) = ((x115==x116) || (\exists integer x119; (((x115<x119) &&
(x119<=x116)) ==> ((('D'==x114[x115]) &&
(x119==(x115+1))) &&
star_D(x114,x119,x116)))));*/
/*@ predicate star_C(char * x135, integer x136, integer x137) = ((x136==x137) || (\exists integer x140; (((x136<x140) &&
(x140<=x137)) ==> ((('C'==x135[x136]) &&
(x140==(x136+1))) &&
star_C(x135,x140,x137)))));*/
/*@ predicate star__orB_or_C_sCs_Bor_(char * x156, integer x157, integer x158) = ((x157==x158) || (\exists integer x161; (((x157<x161) &&
(x161<=x158)) ==> (((('B'==x156[x157]) &&
(x161==(x157+1))) || (\exists integer x170; ((((x157<=x170) &&
(x170<=x161)) &&
(('C'==x156[x157]) &&
(x170==(x157+1)))) &&
(\exists integer x178; ((((x170<=x178) &&
(x178<=x161)) &&
star_C(x156,x170,x178)) &&
(('B'==x156[x178]) &&
(x161==(x178+1)))))))) &&
star__orB_or_C_sCs_Bor_(x156,x161,x158)))));*/
/*@ predicate re_0(char * x0, integer x1, integer x2) = (\exists integer x4; ((((x1<=x4) &&
(x4<=x2)) &&
(('A'==x0[x1]) &&
(x4==(x1+1)))) &&
(\exists integer x14; ((((x4<=x14) &&
(x14<=x2)) &&
star_A(x0,x4,x14)) &&
(\exists integer x21; ((((x14<=x21) &&
(x21<=x2)) &&
(('B'==x0[x14]) &&
(x21==(x14+1)))) &&
(\exists integer x31; ((((x21<=x31) &&
(x31<=x2)) &&
star__orB_or_C_sCs_Bor_(x0,x21,x31)) &&
(\exists integer x38; ((((x31<=x38) &&
(x38<=x2)) &&
(('C'==x0[x31]) &&
(x38==(x31+1)))) &&
(\exists integer x48; ((((x38<=x48) &&
(x48<=x2)) &&
star_C(x0,x38,x48)) &&
(\exists integer x55; ((((x48<=x55) &&
(x55<=x2)) &&
(('D'==x0[x48]) &&
(x55==(x48+1)))) &&
(\exists integer x65; ((((x55<=x65) &&
(x65<=x2)) &&
star_D(x0,x55,x65)) &&
(x65==x2)))))))))))))))));*/
/*@ predicate re_1(char * x201, integer x202, integer x203) = (\exists integer x205; ((((x202<=x205) &&
(x205<=x203)) &&
star_A(x201,x202,x205)) &&
(\exists integer x211; ((((x205<=x211) &&
(x211<=x203)) &&
(('B'==x201[x205]) &&
(x211==(x205+1)))) &&
(\exists integer x221; ((((x211<=x221) &&
(x221<=x203)) &&
star__orB_or_C_sCs_Bor_(x201,x211,x221)) &&
(\exists integer x227; ((((x221<=x227) &&
(x227<=x203)) &&
(('C'==x201[x221]) &&
(x227==(x221+1)))) &&
(\exists integer x237; ((((x227<=x237) &&
(x237<=x203)) &&
star_C(x201,x227,x237)) &&
(\exists integer x243; ((((x237<=x243) &&
(x243<=x203)) &&
(('D'==x201[x237]) &&
(x243==(x237+1)))) &&
(\exists integer x253; ((((x243<=x253) &&
(x253<=x203)) &&
star_D(x201,x243,x253)) &&
(x253==x203)))))))))))))));*/
/*@ predicate re_2(char * x274, integer x275, integer x276) = (\exists integer x278; ((((x275<=x278) &&
(x278<=x276)) &&
star__orB_or_C_sCs_Bor_(x274,x275,x278)) &&
(\exists integer x284; ((((x278<=x284) &&
(x284<=x276)) &&
(('C'==x274[x278]) &&
(x284==(x278+1)))) &&
(\exists integer x294; ((((x284<=x294) &&
(x294<=x276)) &&
star_C(x274,x284,x294)) &&
(\exists integer x300; ((((x294<=x300) &&
(x300<=x276)) &&
(('D'==x274[x294]) &&
(x300==(x294+1)))) &&
(\exists integer x310; ((((x300<=x310) &&
(x310<=x276)) &&
star_D(x274,x300,x310)) &&
(x310==x276)))))))))));*/
/*@ predicate re_3(char * x327, integer x328, integer x329) = (\exists integer x331; ((((x328<=x331) &&
(x331<=x329)) &&
star_C(x327,x328,x331)) &&
(\exists integer x337; ((((x331<=x337) &&
(x337<=x329)) &&
(('D'==x327[x331]) &&
(x337==(x331+1)))) &&
(\exists integer x347; ((((x337<=x347) &&
(x347<=x329)) &&
star_D(x327,x337,x347)) &&
(x347==x329)))))));*/
/*@ predicate re_4(char * x360, integer x361, integer x362) = (\exists integer x364; ((((x361<=x364) &&
(x364<=x362)) &&
star_D(x360,x361,x364)) &&
(x364==x362)));*/
/*@ predicate re_bwd_0(char * x373, integer x374, integer x375) = (x374==x375);*/
/*@ predicate re_bwd_1(char * x378, integer x379, integer x380) = (\exists integer x382; ((((x379<=x382) &&
(x382<=x380)) &&
(('A'==x378[x379]) &&
(x382==(x379+1)))) &&
(\exists integer x392; ((((x382<=x392) &&
(x392<=x380)) &&
star_A(x378,x382,x392)) &&
(x392==x380)))));*/
/*@ predicate re_bwd_2(char * x403, integer x404, integer x405) = (\exists integer x407; ((((x404<=x407) &&
(x407<=x405)) &&
(('A'==x403[x404]) &&
(x407==(x404+1)))) &&
(\exists integer x417; ((((x407<=x417) &&
(x417<=x405)) &&
star_A(x403,x407,x417)) &&
(\exists integer x423; ((((x417<=x423) &&
(x423<=x405)) &&
(('B'==x403[x417]) &&
(x423==(x417+1)))) &&
(\exists integer x433; ((((x423<=x433) &&
(x433<=x405)) &&
star__orB_or_C_sCs_Bor_(x403,x423,x433)) &&
(x433==x405)))))))));*/
/*@ predicate re_bwd_3(char * x448, integer x449, integer x450) = (\exists integer x452; ((((x449<=x452) &&
(x452<=x450)) &&
(('A'==x448[x449]) &&
(x452==(x449+1)))) &&
(\exists integer x462; ((((x452<=x462) &&
(x462<=x450)) &&
star_A(x448,x452,x462)) &&
(\exists integer x468; ((((x462<=x468) &&
(x468<=x450)) &&
(('B'==x448[x462]) &&
(x468==(x462+1)))) &&
(\exists integer x478; ((((x468<=x478) &&
(x478<=x450)) &&
star__orB_or_C_sCs_Bor_(x448,x468,x478)) &&
(\exists integer x484; ((((x478<=x484) &&
(x484<=x450)) &&
(('C'==x448[x478]) &&
(x484==(x478+1)))) &&
(\exists integer x494; ((((x484<=x494) &&
(x494<=x450)) &&
star_C(x448,x484,x494)) &&
(x494==x450)))))))))))));*/
/*@ predicate re_bwd_4(char * x513, integer x514, integer x515) = (\exists integer x517; ((((x514<=x517) &&
(x517<=x515)) &&
(('A'==x513[x514]) &&
(x517==(x514+1)))) &&
(\exists integer x527; ((((x517<=x527) &&
(x527<=x515)) &&
star_A(x513,x517,x527)) &&
(\exists integer x533; ((((x527<=x533) &&
(x533<=x515)) &&
(('B'==x513[x527]) &&
(x533==(x527+1)))) &&
(\exists integer x543; ((((x533<=x543) &&
(x543<=x515)) &&
star__orB_or_C_sCs_Bor_(x513,x533,x543)) &&
(\exists integer x549; ((((x543<=x549) &&
(x549<=x515)) &&
(('C'==x513[x543]) &&
(x549==(x543+1)))) &&
(\exists integer x559; ((((x549<=x559) &&
(x559<=x515)) &&
star_C(x513,x549,x559)) &&
(\exists integer x565; ((((x559<=x565) &&
(x565<=x515)) &&
(('D'==x513[x559]) &&
(x565==(x559+1)))) &&
(\exists integer x575; ((((x565<=x575) &&
(x575<=x515)) &&
star_D(x513,x565,x575)) &&
(x575==x515)))))))))))))))));*/
/*@ predicate star_starting_D(char * x719, integer x720, integer x721) = ((((x720==x721) || (('D'==x719[x720]) &&
(x721>=(x720+1)))) || (\exists integer x730; (((x720<x730) &&
(x730<=x721)) ==> ((('D'==x719[x720]) &&
(x730==(x720+1))) &&
star_starting_D(x719,x730,x721))))) || (x721>=x720));*/
/*@ predicate star_starting_A(char * x745, integer x746, integer x747) = ((((x746==x747) || (('A'==x745[x746]) &&
(x747>=(x746+1)))) || (\exists integer x756; (((x746<x756) &&
(x756<=x747)) ==> ((('A'==x745[x746]) &&
(x756==(x746+1))) &&
star_starting_A(x745,x756,x747))))) || (x747>=x746));*/
/*@ predicate star_starting_C(char * x771, integer x772, integer x773) = ((((x772==x773) || (('C'==x771[x772]) &&
(x773>=(x772+1)))) || (\exists integer x782; (((x772<x782) &&
(x782<=x773)) ==> ((('C'==x771[x772]) &&
(x782==(x772+1))) &&
star_starting_C(x771,x782,x773))))) || (x773>=x772));*/
/*@ predicate star_starting__orB_or_C_sCs_Bor_(char * x797, integer x798, integer x799) = (((((x798==x799) || (('B'==x797[x798]) &&
(x799>=(x798+1)))) || (((x798==x799) || (('C'==x797[x798]) &&
(x799>=(x798+1)))) || (\exists integer x811; ((((x798<=x811) &&
(x811<=x799)) &&
(('C'==x797[x798]) &&
(x811==(x798+1)))) &&
(star_starting_C(x797,x811,x799) || (\exists integer x819; ((((x811<=x819) &&
(x819<=x799)) &&
star_C(x797,x811,x819)) &&
((x819==x799) || (('B'==x797[x819]) &&
(x799>=(x819+1))))))))))) || (\exists integer x839; (((x798<x839) &&
(x839<=x799)) ==> (((('B'==x797[x798]) &&
(x839==(x798+1))) || (\exists integer x845; ((((x798<=x845) &&
(x845<=x839)) &&
(('C'==x797[x798]) &&
(x845==(x798+1)))) &&
(\exists integer x852; ((((x845<=x852) &&
(x852<=x839)) &&
star_C(x797,x845,x852)) &&
(('B'==x797[x852]) &&
(x839==(x852+1)))))))) &&
star_starting__orB_or_C_sCs_Bor_(x797,x839,x799))))) || (x799>=x798));*/
/*@ predicate re0(char * x598, integer x599, integer x600) = (((x599==x600) || (('A'==x598[x599]) &&
(x600>=(x599+1)))) || (\exists integer x609; ((((x599<=x609) &&
(x609<=x600)) &&
(('A'==x598[x599]) &&
(x609==(x599+1)))) &&
(star_starting_A(x598,x609,x600) || (\exists integer x617; ((((x609<=x617) &&
(x617<=x600)) &&
star_A(x598,x609,x617)) &&
(((x617==x600) || (('B'==x598[x617]) &&
(x600>=(x617+1)))) || (\exists integer x630; ((((x617<=x630) &&
(x630<=x600)) &&
(('B'==x598[x617]) &&
(x630==(x617+1)))) &&
(star_starting__orB_or_C_sCs_Bor_(x598,x630,x600) || (\exists integer x638; ((((x630<=x638) &&
(x638<=x600)) &&
star__orB_or_C_sCs_Bor_(x598,x630,x638)) &&
(((x638==x600) || (('C'==x598[x638]) &&
(x600>=(x638+1)))) || (\exists integer x651; ((((x638<=x651) &&
(x651<=x600)) &&
(('C'==x598[x638]) &&
(x651==(x638+1)))) &&
(star_starting_C(x598,x651,x600) || (\exists integer x659; ((((x651<=x659) &&
(x659<=x600)) &&
star_C(x598,x651,x659)) &&
(((x659==x600) || (('D'==x598[x659]) &&
(x600>=(x659+1)))) || (\exists integer x672; ((((x659<=x672) &&
(x672<=x600)) &&
(('D'==x598[x659]) &&
(x672==(x659+1)))) &&
(star_starting_D(x598,x672,x600) || (\exists integer x680; ((((x672<=x680) &&
(x680<=x600)) &&
star_D(x598,x672,x680)) &&
(x600>=x680)))))))))))))))))))))))));*/
/*@
requires (((strlen(x877)>=0) &&
\valid(x877+(0..strlen(x877)))) &&
(strlen(x877)<=INT_MAX));
assigns \nothing;
ensures (\result ==> re_0(x877,0,strlen(x877)));
*/
int dfa(char * x877) {
int x879 = 1/*true*/;
int x880 = 0;
//@ ghost int x881 = 0;
char *x882 = x877;
/*@
loop invariant (((((((((strlen(x877)>=0) &&
\valid(x877+(0..strlen(x877)))) &&
((0<=x881) &&
(x881<=strlen(x877)))) &&
(x882==(x877+x881))) &&
((strlen((x877+x881))>=0) &&
\valid((x877+x881)+(0..strlen((x877+x881)))))) &&
(x879 ==> (((x880==4) ==> re_bwd_4(x877,0,x881)) &&
(((x880==3) ==> re_bwd_3(x877,0,x881)) &&
(((x880==2) ==> re_bwd_2(x877,0,x881)) &&
(((x880==1) ==> re_bwd_1(x877,0,x881)) &&
((x880==0) ==> re_bwd_0(x877,0,x881)))))))) &&
(x879 ==> re0(x877,0,x881))) &&
((x880==4) ==> (re_bwd_4(x877,0,x881) ==> re_0(x877,0,x881)))) &&
((x880==4) || ((x880==3) || ((x880==2) || ((x880==1) || (x880==0))))));
loop assigns x882, x881, x880, x879;
loop variant strlen(x882);
*/
for (;;) {
char *x884 = x882;
char x885 = x884[0];
int x886 = x885 == '\0';
int x890;
if (x886) {
x890 = 0/*false*/;
} else {
int x888 = x879;
x890 = x888;
}
if (!x890) break;
/*@assert (x879 ==> (((x880==4) ==> re_bwd_4(x877,0,x881)) &&
(((x880==3) ==> re_bwd_3(x877,0,x881)) &&
(((x880==2) ==> re_bwd_2(x877,0,x881)) &&
(((x880==1) ==> re_bwd_1(x877,0,x881)) &&
((x880==0) ==> re_bwd_0(x877,0,x881)))))));*/
/*@assert (((x880==4) ==> re_bwd_4(x877,0,x881)) &&
(((x880==3) ==> re_bwd_3(x877,0,x881)) &&
(((x880==2) ==> re_bwd_2(x877,0,x881)) &&
(((x880==1) ==> re_bwd_1(x877,0,x881)) &&
((x880==0) ==> re_bwd_0(x877,0,x881))))));*/
char *x942 = x882;
int x944 = x880;
int x945 = x944 == 4;
int x1160;
if (x945) {
char x943 = x942[0];
int x946 = 'D' == x943;
int x967;
if (x946) {
/*@assert re_bwd_4(x877,0,(x881+1));*/
x880 = 4;
/*@assert re_bwd_4(x877,0,(x881+1));*/
/*@assert ((x880==4) ==> re_bwd_4(x877,0,(x881+1)));*/
x967 = 1/*true*/;
} else {
x967 = 0/*false*/;
}
x1160 = x967;
} else {
int x969 = x944 == 3;
int x1158;
if (x969) {
char x943 = x942[0];
int x946 = 'D' == x943;
int x1036;
if (x946) {
/*@assert re_bwd_4(x877,0,(x881+1));*/
x880 = 4;
/*@assert re_bwd_4(x877,0,(x881+1));*/
/*@assert ((x880==4) ==> re_bwd_4(x877,0,(x881+1)));*/
x1036 = 1/*true*/;
} else {
int x990 = 'C' == x943;
int x1034;
if (x990) {
/*@assert re_bwd_3(x877,0,(x881+1));*/
x880 = 3;
/*@assert re_bwd_3(x877,0,(x881+1));*/
/*@assert ((x880==3) ==> re_bwd_3(x877,0,(x881+1)));*/
x1034 = 1/*true*/;
} else {
int x1011 = 'B' == x943;
int x1032;
if (x1011) {
/*@assert re_bwd_2(x877,0,(x881+1));*/
x880 = 2;
/*@assert re_bwd_2(x877,0,(x881+1));*/
/*@assert ((x880==2) ==> re_bwd_2(x877,0,(x881+1)));*/
x1032 = 1/*true*/;
} else {
x1032 = 0/*false*/;
}
x1034 = x1032;
}
x1036 = x1034;
}
x1158 = x1036;
} else {
int x1038 = x944 == 2;
int x1156;
if (x1038) {
char x943 = x942[0];
int x990 = 'C' == x943;
int x1081;
if (x990) {
/*@assert re_bwd_3(x877,0,(x881+1));*/
x880 = 3;
/*@assert re_bwd_3(x877,0,(x881+1));*/
/*@assert ((x880==3) ==> re_bwd_3(x877,0,(x881+1)));*/
x1081 = 1/*true*/;
} else {
int x1011 = 'B' == x943;
int x1079;
if (x1011) {
/*@assert re_bwd_2(x877,0,(x881+1));*/
x880 = 2;
/*@assert re_bwd_2(x877,0,(x881+1));*/
/*@assert ((x880==2) ==> re_bwd_2(x877,0,(x881+1)));*/
x1079 = 1/*true*/;
} else {
x1079 = 0/*false*/;
}
x1081 = x1079;
}
x1156 = x1081;
} else {
int x1083 = x944 == 1;
int x1154;
if (x1083) {
char x943 = x942[0];
int x1011 = 'B' == x943;
int x1127;
if (x1011) {
/*@assert re_bwd_2(x877,0,(x881+1));*/
x880 = 2;
/*@assert re_bwd_2(x877,0,(x881+1));*/
/*@assert ((x880==2) ==> re_bwd_2(x877,0,(x881+1)));*/
x1127 = 1/*true*/;
} else {
int x1104 = 'A' == x943;
int x1125;
if (x1104) {
/*@assert re_bwd_1(x877,0,(x881+1));*/
x880 = 1;
/*@assert re_bwd_1(x877,0,(x881+1));*/
/*@assert ((x880==1) ==> re_bwd_1(x877,0,(x881+1)));*/
x1125 = 1/*true*/;
} else {
x1125 = 0/*false*/;
}
x1127 = x1125;
}
x1154 = x1127;
} else {
int x1129 = x944 == 0;
int x1152;
if (x1129) {
char x943 = x942[0];
int x1104 = 'A' == x943;
int x1150;
if (x1104) {
/*@assert re_bwd_1(x877,0,(x881+1));*/
x880 = 1;
/*@assert re_bwd_1(x877,0,(x881+1));*/
/*@assert ((x880==1) ==> re_bwd_1(x877,0,(x881+1)));*/
x1150 = 1/*true*/;
} else {
x1150 = 0/*false*/;
}
x1152 = x1150;
} else {
x1152 = 0/*false*/;
}
x1154 = x1152;
}
x1156 = x1154;
}
x1158 = x1156;
}
x1160 = x1158;
}
x879 = x1160;
/*@assert (x879 ==> (((x880==4) ==> re_bwd_4(x877,0,(x881+1))) &&
(((x880==3) ==> re_bwd_3(x877,0,(x881+1))) &&
(((x880==2) ==> re_bwd_2(x877,0,(x881+1))) &&
(((x880==1) ==> re_bwd_1(x877,0,(x881+1))) &&
((x880==0) ==> re_bwd_0(x877,0,(x881+1))))))));*/
//@ ghost int x1189 = x881;
//@ ghost int x1190 = x1189 + 1;
//@ ghost x881 = x1190;
char *x1192 = x942+1;
x882 = x1192;
/*@assert (x879 ==> (((x880==4) ==> re_bwd_4(x877,0,x881)) &&
(((x880==3) ==> re_bwd_3(x877,0,x881)) &&
(((x880==2) ==> re_bwd_2(x877,0,x881)) &&
(((x880==1) ==> re_bwd_1(x877,0,x881)) &&
((x880==0) ==> re_bwd_0(x877,0,x881)))))));*/
}
int x1312 = x880;
char *x1313 = x882;
char x1314 = x1313[0];
int x1315 = x1314 == '\0';
int x1318;
if (x1315) {
int x1316 = x879;
x1318 = x1316;
} else {
x1318 = 0/*false*/;
}
int x1320;
if (x1318) {
int x1319 = 4 == x1312;
x1320 = x1319;
} else {
x1320 = 0/*false*/;
}
return x1320;
}
| 84
|
/*@
axiomatic IntArray {
type int_array;
logic int access(int_array a, integer i);
logic int_array update(int_array a, integer i, int v);
axiom access_update_eq :
\forall int_array a, integer i, int v; access(update(a, i, v), i) == v;
axiom access_update_neq :
\forall int_array a, integer i, integer j, int v;
i != j ==> access(update(a, i, v), j) == access(a, j);
}
*/
/*@
predicate Swap(int_array a1, int_array a2, integer i, integer j) =
access(a1, i) == access(a2, j) &&
access(a1, j) == access(a2, i) &&
\forall integer k; k != i ==> k != j ==> access(a1, k) == access(a2, k) ;
*/
/*@
axiomatic Permut {
predicate Permut(int_array a1, int_array a2, integer l, integer h);
axiom Permut_refl:
\forall int_array a; \forall integer l, integer h; Permut(a, a, l, h);
axiom Permut_sym:
\forall int_array a1, int_array a2, integer l, integer h;
Permut(a1, a2, l, h) ==> Permut(a2, a1, l, h);
axiom Permut_trans:
\forall int_array a1, int_array a2, int_array a3, integer l, integer h;
Permut(a1, a2, l, h) ==> Permut(a2, a3, l, h) ==> Permut(a1, a3, l, h);
axiom Permut_swap:
\forall int_array a1, int_array a2, integer l, integer h, integer i, integer j;
l <= i <= h ==> l <= j <= h ==> Swap(a1, a2, i, j) ==> Permut(a1, a2, l, h);
axiom Permut_extend:
\forall int_array a1, int_array a2, integer l, integer h, integer ll, integer hh;
Permut(a1, a2, l, h) ==> ll <= l ==> h <= hh ==> Permut(a1, a2, ll, hh);
}
*/
/*@
axiomatic ArrayContents {
logic int_array contents{L}(int* a)
reads a[..];
axiom access_contents{L} :
\forall int* a; \forall integer i; access(contents(a), i) == a[i];
}
*/
/*@
predicate Sorted{L}(int* a, integer l, integer h) =
\forall integer i; l <= i < h ==> a[i] <= a[i+1] ;
*/
/*@
predicate Hnode{L}(int* a, integer i, integer h) =
(2*i+1 <= h ==> a[i] >= a[2*i+1]) &&
(2*i+2 <= h ==> a[i] >= a[2*i+2]) ;
*/
/*@
predicate H{L}(int* a, integer l, integer h) =
\forall integer i; l <= i <= h ==> Hnode{L}(a, i, h) ;
*/
//@ lemma H_init{L}: \forall int* a, integer l, integer h; l <= h < 2*l+1 ==> H{L}(a, l, h);
//@ lemma H_reduce{L}: \forall int* a, integer h; 0 < h ==> H{L}(a, 0, h) ==> H{L}(a, 1, h-1);
/*@
lemma H_max{L}:
\forall int* a, integer h;
H{L}(a, 0, h) ==> \forall integer i; 0 <= i <= h ==> a[0] >= a[i];
*/
//@ lemma div2_1 : \forall int i; 0 <= i ==> 0 <= i/2 <= i;
//@ lemma div2_2 : \forall int i; 0 < i ==> 0 <= i/2 < i;
//@ lemma div2_3 : \forall int i; 0 <= i ==> i-1 < 2*(i/2)+1;
/*@
lemma div2_4 : \forall int i, int k;
0 <= i ==> 0 <= k ==> k != (i-1)/2 ==> 2*k+1 != i;
*/
/*@
lemma div2_5 : \forall int i, int k;
0 <= i ==> 0 <= k ==> k != (i-1)/2 ==> 2*k+2 != i;
*/
/*@
requires 0 <= low <= high && \valid_range(a, low, high) && H(a, low+1, high);
assigns a[low..high];
ensures Permut(contents(a), \old(update(contents(a), low, v)), low, high) && H(a, low, high);
*/
void sift_down(int* a, unsigned int low, unsigned int high, int v) {
unsigned int i = low, child;
/*@
loop invariant
low <= i <= high &&
Permut(contents(a), \at(contents(a), Pre), low, high) &&
(\forall int k; low < k <= high ==> Hnode(a, k, high)) &&
(low < i ==> Hnode(a, low, high)) &&
(low <= (i-1)/2 ==> a[(i-1)/2] >= v);
loop assigns
a[low..high];
loop variant
high - i;
*/
while ((child = 2*i+1) <= high) {
if (child+1 <= high && a[child+1] >= a[child])
child++;
if (v >= a[child])
break;
a[i] = a[child];
//@ assert Hnode(a, i, high);
i = child;
}
a[i] = v;
}
/*@
requires 0 <= n && \valid_range(a, 0, n-1);
ensures Permut(contents(a), \old(contents(a)), 0, n-1) && Sorted(a, 0, n-1);
*/
void heapsort(int* a, unsigned int n) {
unsigned int i;
if (n <= 1) return;
/*@
loop invariant
0 <= i < n &&
Permut(contents(a), \at(contents(a), Pre), 0, n-1) &&
H(a, i, n-1);
loop variant i;
*/
for (i = n/2; i >= 1; i--) sift_down(a, i-1, n-1, a[i-1]);
/*@
loop invariant
0 <= i < n &&
Permut(contents(a), \at(contents(a), Pre), 0, n-1) &&
H(a, 0, i) && Sorted(a, i+1, n-1) &&
\forall int k1, int k2; 0 <= k1 <= i ==> i < k2 < n ==> a[k1] <= a[k2];
loop variant i;
*/
for (i = n-1; i >= 1; i--) {
int tmp = a[i];
a[i] = a[0];
sift_down(a, 0, i-1, tmp);
}
}
| 84
|
/*@ axiomatic abs {
@ logic int abs(int x);
@ axiom pos: \forall int x; x >= 0 ==> abs(x) == x;
@ axiom neg: \forall int x; x <= 0 ==> abs(x) == -x;
@ }
*/
/*@ ensures \result == abs(x);
@ assigns \nothing;
*/
int abs(int x);
/*@ ensures (\result == x || \result == y)
@ && \result >= x && \result >= y;
@ assigns \nothing;
*/
int max(int x, int y);
/*@ ensures \result >= 0;
@ assigns \nothing;
*/
int max_abs(int x, int y) {
x = abs(x);
y = abs(y);
return max(x, y);
}
| 10
|
#include <limits.h>
/*@ predicate inv_vec_Int(int * x0, int x1) = ((x1==0) || ((x1>0) &&
\valid(x0+(0..x1-1))));*/
/*@ predicate inv_vec_vec_Int(int * * x16, int * x17, int x18) = (((x18==0) || ((x18>0) &&
(\valid(x16+(0..x18-1)) &&
\valid(x17+(0..x18-1))))) &&
(\forall int x28; (0<=x28<x18) ==> ((x17[x28]==0) || ((x17[x28]>0) &&
\valid(x16[x28]+(0..x17[x28]-1))))));*/
/*@
requires inv_vec_vec_Int(x66,x67,x68);
assigns \nothing;
ensures inv_vec_vec_Int(x66,x67,x68);
*/
int count_pos(int * * x66, int * x67, int x68) {
int x70 = 0;
/*@
loop invariant 0<=x72<=x68;
loop invariant ((0<=x70) &&
(x70<=x72));
loop assigns x72, x70;
loop variant x68-x72;
*/
for(int x72=0; x72 < x68; x72++) {
int x75 = x70;
int x81 = 0;
int x74 = x67[x72];
int *x73 = x66[x72];
/*@
loop invariant 0<=x83<=x74;
loop invariant ((0<=x81) &&
(x81<=x83));
loop assigns x83, x81;
loop variant x74-x83;
*/
for(int x83=0; x83 < x74; x83++) {
int x85 = x81;
int x84 = x73[x83];
int x91 = x84 > 0;
int x92;
if (x91) {
x92 = 1;
} else {
x92 = 0;
}
int x93 = x85 + x92;
x81 = x93;
}
int x97 = x81;
int x98 = x97 > 0;
int x99;
if (x98) {
x99 = 1;
} else {
x99 = 0;
}
int x100 = x75 + x99;
x70 = x100;
}
int x104 = x70;
return x104;
}
| 32
|
/*@
requires \valid(q) && \valid(r);
requires 0<y<1000000000 && 0<=x<1000000000;
assigns *q, *r ;
*/
void div_rem(unsigned x,unsigned y,unsigned* q,unsigned* r){
*q = x / y ;
//@ assert *q==x/y;
*r = x % y ;
//@ assert *r==x%y;
}
| 10
|
/* run.config_qualif
DONTRUN:
*/
#define NULL ((void *) 0L)
/*@
ensures e1: \result == \null;
ensures e2: \result == 0;
ensures e3: \result == (int *) \null;
ensures e4: \result == (int *) 0;
ensures e5: \result == (int *)((void *)0);
*/
int * f (void) {
return NULL;
}
| 7
|
#include <limits.h>
/*@
requires x > INT_MIN;
ensures 0 <= x ==> \result == x;
ensures 0 > x ==> \result == -x;
*/
int abs_int(int x)
{
return (x >= 0) ? x : -x;
}
| 5
|
#include <stdio.h>
#include <stdlib.h>
/*@
requires n >= 0;
requires \valid_read(a+(0..n-1));
ensures \forall integer k; 0 <= k < n ==> a[k] == a[k]+c;
*/
void arrayinc(int *a,int n,int c){
/*@
loop invariant 0 <= p <= n;
loop invariant \forall integer k; 0 <= k < p ==> a[k] == a[k]+c;
loop invariant \forall integer k; p <= k < n ==> a[k] == a[k];
loop assigns p,a[0..(n-1)];
*/
for(int p = 0;p < n;p++){
a[p] = a[p] + c;
}
}
int main(){
int a[] = {1,2,3,4,5};
int n = 5;
int c = 2;
arrayinc(a,n,c);
return 0;
}
| 5
|
#define SPEC_INT_MIN -2147483648
#define SPEC_INT_MAX 2147483647
/*@ assigns \nothing;
ensures \result >= 0;
behavior positive:
assumes a > 0;
ensures \result == a;
behavior zero:
assumes a == 0;
ensures \result == 0;
ensures \result == a;
behavior negative:
assumes a < 0;
ensures \result == -a;
complete behaviors;
disjoint behaviors;
*/
long spec_abs1(int a)
{
long abs;
abs = a;
if (a < 0) {
abs = -abs;
}
return abs;
}
#ifdef OUT_OF_TASK
#include <stdio.h>
int main(void)
{
printf("res: %ld\n", spec_abs1(SPEC_INT_MIN + 1));
return 0;
}
#endif
| 12
|
#include<stdbool.h>
/*@
axiomatic error_bounds {
logic real ulp(real X);
logic real errAdd( real X, real Y, real E_X, real E_Y)
= E_X + E_Y + ulp(\abs(X + Y) + E_X + E_Y)/2;
logic real errSub( real X, real Y, real E_X, real E_Y)
= E_X + E_Y + ulp(\abs(X - Y) + E_X + E_Y)/2;
}
*/
struct maybeInt {
bool isValid;
int value;
};
/*@ assigns \nothing;
ensures ! \result.isValid;
*/
struct maybeInt none () {
struct maybeInt result = { false, 0 };
return result;
}
/*@ assigns \nothing;
ensures \result.isValid;
ensures \result.value == val;
*/
struct maybeInt some (int val) {
struct maybeInt result = { true, val };
return result;
}
struct maybeFloat {
bool isValid;
float value;
};
/*@ assigns \nothing;
ensures ! \result.isValid;
*/
struct maybeFloat noneFloat () {
struct maybeFloat result = { false, 0 };
return result;
}
/*@ assigns \nothing;
ensures \result.isValid;
ensures \result.value == val;
*/
struct maybeFloat someFloat (float val) {
struct maybeFloat result = { true, val };
return result;
}
struct maybeDouble {
bool isValid;
double value;
};
/*@ assigns \nothing;
ensures ! \result.isValid;
*/
struct maybeDouble noneDouble () {
struct maybeDouble result = { false, 0 };
return result;
}
/*@ assigns \nothing;
ensures \result.isValid;
ensures \result.value == val;
*/
struct maybeDouble someDouble (double val) {
struct maybeDouble result = { true, val };
return result;
}
struct maybeBool {
bool isValid;
double value;
};
/*@ assigns \nothing;
ensures ! \result.isValid;
*/
struct maybeBool noneBool () {
struct maybeBool result = { false, false };
return result;
}
/*@ assigns \nothing;
ensures \result.isValid;
ensures \result.value == val;
*/
struct maybeBool someBool (bool val) {
struct maybeBool result = { true, val };
return result;
}
| 36
|
/*@ ensures \result <= sizeof(int); */
int f() { return sizeof(char); }
| 3
|
/*
* memswap()
*
* Swaps the contents of two nonoverlapping memory areas.
* This really could be done faster...
*/
#include <string.h>
/*@
requires n >= 0;
requires \valid(((char*)m1)+(0..n-1));
requires \valid(((char*)m2)+(0..n-1));
requires \separated(((char*)m1)+(0..n-1), ((char*)m2)+(0..n-1));
assigns ((char*)m1)[0..n-1];
assigns ((char*)m2)[0..n-1];
ensures \forall integer i; 0 <= i < n ==> ((char*)m1)[i] == \old(((char*)m2)[i]);
ensures \forall integer i; 0 <= i < n ==> ((char*)m2)[i] == \old(((char*)m1)[i]);
@*/
void memswap(void *m1, void *m2, size_t n)
{
char *p = m1;
char *q = m2;
char tmp;
/*@
loop invariant \base_addr(p) == \base_addr(m1);
loop invariant \base_addr(q) == \base_addr(m2);
loop invariant 0 <= n <= \at(n, Pre);
loop invariant p == m1+(\at(n, Pre) - n);
loop invariant q == m2+(\at(n, Pre) - n);
loop invariant \forall integer i; 0 <= i < (\at(n, Pre) - n) ==> ((char*)m2)[i] == \at(((char*)m1)[i], Pre);
loop invariant \forall integer i; 0 <= i < (\at(n, Pre) - n) ==> ((char*)m1)[i] == \at(((char*)m2)[i], Pre);
loop invariant \forall integer i; (\at(n, Pre) - n) <= i < \at(n, Pre) ==> ((char*)m1)[i] == \at(((char*)m1)[i], Pre);
loop invariant \forall integer i; (\at(n, Pre) - n) <= i < \at(n, Pre) ==> ((char*)m2)[i] == \at(((char*)m2)[i], Pre);
loop assigns n, tmp, ((char*)m1)[0..(\at(n, Pre) - n - 1)], ((char*)m2)[0..(\at(n, Pre) - n - 1)], p, q;
loop variant n;
@*/
while (/*n--*/ n) {
tmp = *p;
*p = *q;
*q = tmp;
p++;
q++;
n--; // inserted code
}
}
| 33
|
/* run.config
COMMENT: bts #1478 about wrong detection of initializers in pre-analysis
*/
int global_i;
int* global_i_ptr = &global_i;
int global_i = 0;
/*@ requires global_i == 0;
requires \valid(global_i_ptr);
requires global_i_ptr == &global_i; */
void loop(void) { }
int main(void) {
loop();
return 0;
}
| 7
|
/*@ requires \valid(p+ (0..1));
ensures p[0] == \old(p[1]);
ensures p[1] == \old(p[0]);
assigns p[0], p[1];
*/
void array_swap(int* p) {
int tmp = p[0];
p[0] = p[1];
p[1] = tmp;
}
| 10
|
// Returns the index of an element in a given array
/*@ requires n>0;
requires \valid(t+(0..n-1));
behavior success:
assumes \exists integer i; 0<=i<n && t[i] == e;
ensures 0 <= \result < n && t[\result]==e;
behavior failure:
assumes \forall integer i; 0<=i<n ==> t[i]!=e;
ensures \result==-1;
*/
int index(int t[],int n,int e) {
/*@ loop invariant 0<=i<=n;
loop invariant \forall integer j; 0<=j<i ==> t[j] == e;
loop variant n-i;
*/
for(int i=0;i<n;i++) {
if( t[i] == e ) return i;
}
return -1;
}
| 10
|
#define SPEC_INT_MIN -2147483648
#define SPEC_INT_MAX 2147483647
/*@ //requires SPEC_INT_MIN < a <= SPEC_INT_MAX;
requires SPEC_INT_MIN < a;
assigns \nothing;
ensures \result >= 0;
behavior positive:
assumes a > 0;
ensures \result == a;
behavior zero:
assumes a == 0;
ensures \result == 0;
ensures \result == a;
behavior negative:
assumes a < 0;
ensures \result == -a;
complete behaviors;
disjoint behaviors;
*/
int spec_abs2(int a)
{
int abs;
if (a < 0) {
abs = -a;
} else {
abs = a;
}
return abs;
}
#ifdef OUT_OF_TASK
#include <stdio.h>
int main(void)
{
printf("res: %d\n", spec_abs2(SPEC_INT_MIN + 1));
return 0;
}
#endif
| 12
|
/* Run with:
*
* frama-c -wp -wp-rte -wp-prover alt-ergo -wp-timeout 10 -wp-verbose 0 \
* kylikeio.c -then -report
*
* Tested with Frama-C Aluminium-20160502.
*/
/*@ predicate canSee{L}(integer N, int *x, integer i) =
@ \forall integer j; i < j < N ==> \at(x[i], L) > \at(x[j], L);
@*/
/*@ predicate countRangeFrom{L}(integer N, int *x, integer i, integer c) =
@ i >= N ? c == 0 :
@ canSee{L}(N, x, i) ? countRangeFrom{L}(N, x, i+1, c-1)
@ : countRangeFrom{L}(N, x, i+1, c);
@*/
/*@ requires N > 0;
@ requires \valid(a + (0..N-1));
@ ensures countRangeFrom(N, a, 0, \result);
@*/
int count(int N, int* a) {
int max = a[N-1];
int result = 1;
/*@ loop invariant -1 <= i <= N-2;
@ loop invariant result + i <= N-1;
@ loop invariant \exists integer j; i < j < N && a[j] == max;
@ loop invariant \forall integer j; i < j < N ==> a[j] <= max;
@ loop invariant countRangeFrom(N, a, i+1, result);
@ loop assigns i, max, result;
@ loop variant i+1;
@*/
for (int i = N-2; i >= 0; --i)
if (a[i] > max) {
max = a[i];
++result;
}
return result;
}
| 23
|
#include <limits.h>
/*@ requires x > INT_MIN;
assigns \nothing;
behavior positive:
assumes x >= 0;
ensures \result == x;
behavior negative:
assumes x < 0;
ensures \result == -x;
complete behaviors;
disjoint behaviors;
*/
int abs(int x) {
if (x < 0)
return -x;
else if(x >= 0)
return x;
}
| 11
|
/*
* @UBERXMHF_LICENSE_HEADER_START@
*
* uber eXtensible Micro-Hypervisor Framework (Raspberry Pi)
*
* Copyright 2018 Carnegie Mellon University. All Rights Reserved.
*
* NO WARRANTY. THIS CARNEGIE MELLON UNIVERSITY AND SOFTWARE ENGINEERING
* INSTITUTE MATERIAL IS FURNISHED ON AN "AS-IS" BASIS. CARNEGIE MELLON
* UNIVERSITY MAKES NO WARRANTIES OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
* AS TO ANY MATTER INCLUDING, BUT NOT LIMITED TO, WARRANTY OF FITNESS FOR
* PURPOSE OR MERCHANTABILITY, EXCLUSIVITY, OR RESULTS OBTAINED FROM USE OF
* THE MATERIAL. CARNEGIE MELLON UNIVERSITY DOES NOT MAKE ANY WARRANTY OF
* ANY KIND WITH RESPECT TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT
* INFRINGEMENT.
*
* Released under a BSD (SEI)-style license, please see LICENSE or
* contact [email protected] for full terms.
*
* [DISTRIBUTION STATEMENT A] This material has been approved for public
* release and unlimited distribution. Please see Copyright notice for
* non-US Government use and distribution.
*
* Carnegie Mellon is registered in the U.S. Patent and Trademark Office by
* Carnegie Mellon University.
*
* @UBERXMHF_LICENSE_HEADER_END@
*/
/*
* Author: Amit Vasudevan ([email protected])
*
*/
#include <stdint.h>
#include <string.h>
/*
u32 strnlen(const char * s, u32 count){
const char *sc;
for (sc = s; count-- && *sc != '\0'; ++sc);
return (u32)(sc - s);
}*/
/*@
requires maxlen >= 0;
requires \valid(s+(0..maxlen-1));
assigns \nothing;
behavior bigger:
assumes \forall integer i; 0 <= i < maxlen ==> s[i] != 0;
ensures \result == maxlen;
behavior smaller:
assumes \exists integer i; 0 <= i < maxlen && s[i] == 0;
ensures \result <= maxlen;
complete behaviors;
disjoint behaviors;
*/
size_t strnlen(const char *s, size_t maxlen)
{
const char *ss = s;
/* Important: the maxlen test must precede the reference through ss;
since the byte beyond the maximum may segfault */
/*@
loop invariant 0 <= maxlen <= \at(maxlen,Pre);
loop invariant \forall integer i; 0 <= i < (\at(maxlen, Pre) - maxlen) ==> s[i] != 0;
loop invariant ss == s+(\at(maxlen, Pre) - maxlen);
loop invariant s <= ss <= s+\at(maxlen, Pre);
loop assigns maxlen, ss;
loop variant maxlen;
*/
while ((maxlen > 0) && *ss) {
ss++;
maxlen--;
}
return ss - s;
}
| 21
|
#include <limits.h>
#include <string.h>
/*@
requires (((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0)))) &&
(strlen(x0)<=INT_MAX));
assigns \nothing;
*/
int dfa(char * x0) {
int x2 = 1/*true*/;
int x3 = 0;
//@ ghost int x4 = 0;
char *x5 = x0;
/*@
loop invariant (((((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0)))) &&
((0<=x4) &&
(x4<=strlen(x0)))) &&
(x5==(x0+x4))) &&
((strlen((x0+x4))>=0) &&
\valid((x0+x4)+(0..strlen((x0+x4))))));
loop invariant ((x5[0]=='\0') ==> (strlen(x0)==x4));
loop invariant ((!(x5[0]=='\0')) ==> (strlen(x0)!=x4));
loop invariant ((x3==4) || ((x3==3) || ((x3==2) || ((x3==1) || (x3==0)))));
loop assigns x5, x4, x3, x2;
loop variant strlen(x5);
*/
for (;;) {
char *x7 = x5;
char x8 = x7[0];
int x9 = x8 == '\0';
int x13;
if (x9) {
x13 = 0/*false*/;
} else {
int x11 = x2;
x13 = x11;
}
if (!x13) break;
char *x41 = x5;
char *x42 = x41+1;
x5 = x42;
/*@ghost x4 = (x4+1);*/
}
char *x88 = x5;
char x89 = x88[0];
int x90 = x89 == '\0';
int x93;
if (x90) {
int x91 = x2;
x93 = x91;
} else {
x93 = 0/*false*/;
}
int x97;
if (x93) {
int x94 = x3;
int x95 = x94 == 4;
x97 = x95;
} else {
x97 = 0/*false*/;
}
/*@assert ((x5[0]=='\0') || (!x2));*/
return x97;
}
| 26
|
#include <limits.h>
/*@ predicate inv_vec_Int(int * x0, int x1) = ((x1==0) || ((x1>0) &&
\valid(x0+(0..x1-1))));*/
/*@
requires inv_vec_Int(x16,x17);
assigns \nothing;
ensures inv_vec_Int(x16,x17);
*/
int count_pos(int * x16, int x17) {
int x19 = 0;
/*@
loop invariant 0<=x21<=x17;
loop invariant ((0<=x19) &&
(x19<=x21));
loop assigns x21, x19;
loop variant x17-x21;
*/
for(int x21=0; x21 < x17; x21++) {
int x23 = x19;
int x22 = x16[x21];
int x29 = x22 > 0;
int x30;
if (x29) {
x30 = 1;
} else {
x30 = 0;
}
int x31 = x23 + x30;
x19 = x31;
}
int x35 = x19;
return x35;
}
| 17
|
/*@
requires \valid(p);
assigns \nothing;
ensures \result == 42;
*/
int foo(int* p) {
return 42;
}
| 4
|
/*@ predicate sorted(int *t,integer i,integer j) =
@ \forall integer k, integer l; i <= k < l <= j ==> t[k] <= t[l];
@*/
/*@ requires N>=1 && \valid(A+(0..N-1));
@ assigns A[0..N-1];
@ ensures sorted(A,0,N-1);
@*/
void insertionSort(int A[], int N) {
int i, j, key;
/*@ loop assigns i, key, j, A[0..i-1];
@ loop invariant 1<=i<=N && sorted(A,0,i);
@ loop variant N-i;
@*/
for (i=1 ; i<N ; i++) {
key = A[i];
j = i;
/*@ loop assigns j, A[0..i];
@ loop invariant 0 <= j <= i;
@ loop invariant j == i ==> sorted(A,0,i);
@ loop invariant j < i ==> sorted(A,0,i+1);
@ loop invariant \forall integer k; j+1 <= k <= i ==> key < A[k];
@ loop variant j;
@*/
while (j>0 && A[j-1] > key) {
A[j] = A[j-1];
j--;
}
A[j] = key;
}
}
/*
let insertion_sort (a: array int) =
ensures { sorted a }
for i = 1 to length a - 1 do
invariant { sorted_sub a 0 i }
let v = a[i] in
let j = ref i in
while !j > 0 && a[!j - 1] > v do
invariant { 0 <= !j <= i }
invariant { !j = i -> sorted_sub a 0 i }
invariant { !j < i -> sorted_sub a 0 (i+1) }
invariant { forall k: int. !j+1 <= k <= i -> v < a[k] }
variant { !j }
a[!j] <- a[!j - 1];
j := !j - 1
done;
a[!j] <- v
done
*/
| 4
|
struct counter
{
int seconds, minutes, hours;
};
struct counter c;
/*@
requires 0<=c.seconds<60 && 0<=c.minutes<60 && 0<=c.hours<24;
behavior one:
assumes c.seconds < 59 && c.minutes < 59;
ensures c.seconds == \old(c.seconds)+1;
behavior two:
assumes c.seconds == 59 && c.minutes < 59;
ensures c.seconds == 0;
ensures c.minutes == \old(c.minutes)+1;
behavior three:
assumes c.seconds < 59 && c.minutes == 59;
ensures c.seconds == \old(c.seconds)+1;
behavior four:
assumes c.seconds == 59 && c.minutes == 59 && c.hours < 23 ;
ensures c.seconds == 0;
ensures c.minutes == 0;
ensures c.hours == \old(c.hours)+1;
behavior five:
assumes c.seconds == 59 && c.minutes == 59 && c.hours == 23 ;
ensures c.seconds == 0;
ensures c.minutes == 0;
ensures c.hours == 0;
complete behaviors;
disjoint behaviors;
*/
void tick()
{
if (c.seconds < 59)
c.seconds++;
else
{
c.seconds = (c.seconds + 1) % 60;
if (c.minutes < 59)
c.minutes++;
else
c.minutes = (c.minutes + 1) % 60;
if (c.hours < 23)
c.hours++;
else
c.hours = 0;
}
}
| 19
|
/*@
requires n >= 0;
requires \valid(t+(0..(n-1)));
behavior empty :
assumes n==0;
ensures \result==0;
behavior not_empty:
assumes n>0;
ensures 0 <= \result < n;
ensures \forall integer k; 0 <= k < n ==> t[k] >= t[\result];
ensures \forall integer k; 0 <= k < \result ==> t[k] > t[\result];
complete behaviors empty, not_empty;
disjoint behaviors empty, not_empty;
*/
int min(int * t, int n) {
if (n==0) {
return 0;
} else {
int maxInd = 0;
int i =0;
/*@
loop assigns i, maxInd;
loop invariant 0 <= i <= n;
loop invariant 0 <= maxInd < n;
loop invariant 0 <= maxInd <= i;
loop invariant \forall integer k; 0 <= k < i ==> t[k] >= t[maxInd];
loop invariant \forall integer k; 0 <= k < maxInd ==> t[k] > t[maxInd];
loop variant n-i;
*/
for(i=0;i<n;i++) {
if (t[i] < t[maxInd]) {
maxInd = i;
}
}
return maxInd;
}
}
| 24
|
#include <string.h>
/*@
logic integer cypher(integer s) = s==26 ? 0 : s+1;
logic integer decypher(integer s) = s==0 ? 26 : s-1;
*/
/*@
requires 0 <= s <= 26;
ensures 0 <= \result <= 26;
ensures \result == cypher(s);
assigns \nothing;
*/
int cypher(int s) {
return s==26 ? 0 : s+1;
}
/*@
requires 0 <= s <= 26;
ensures 0 <= \result <= 26;
ensures \result == decypher(s);
assigns \nothing;
*/
int decypher(int s) {
return s==0 ? 26 : s-1;
}
/*@
requires n > 0;
requires \valid(s1+(0..n-1));
requires \valid(s2+(0..n-1));
requires \valid(s3+(0..n-1));
requires \forall int i1,i2,i3; 0 <= i1 < n && 0 <= i2 < n && 0 <= i3 < n ==> \separated(s1+i1,s2+i2,s3+i3);
requires \forall int i; 0 <= i < n ==> 0 <= s1[i] <= 26;
ensures \forall int i; 0 <= i < n ==> s2[i]==cypher(s1[i]);
ensures \forall int i; 0 <= i < n ==> 0 <= s2[i] <= 26;
ensures \forall int i; 0 <= i < n ==> \old(s1[i])==s1[i];
ensures \forall int i; 0 <= i < n ==> \old(s3[i])==s3[i];
assigns s2[0..n-1];
*/
void encode(int* s1, int* s2, int* s3, int n) {
/*@
loop invariant 0 <= i <= n;
loop invariant \forall int j; 0 <= j < n ==> 0 <= s1[j] <= 26;
loop invariant \forall int i; 0 <= i < n ==> \at(s1[i],Pre)==s1[i];
loop invariant \forall int i; 0 <= i < n ==> \at(s3[i],Pre)==s3[i];
loop invariant \forall int j; 0 <= j < i ==> s2[j]==cypher(s1[j]);
loop assigns i, s2[0..n-1];
loop variant n - i;
*/
for (int i=0; i<n; i++) {
s2[i] = cypher(s1[i]);
}
}
/*@
requires n > 0;
requires \valid(s1+(0..n-1));
requires \valid(s2+(0..n-1));
requires \valid(s3+(0..n-1));
requires \forall int i1,i2,i3; 0 <= i1 < n && 0 <= i2 < n && 0 <= i3 < n ==> \separated(s1+i1,s2+i2,s3+i3);
requires \forall int i; 0 <= i < n ==> 0 <= s1[i] <= 26;
ensures \forall int i; 0 <= i < n ==> s2[i]==decypher(s1[i]);
ensures \forall int i; 0 <= i < n ==> 0 <= s2[i] <= 26;
ensures \forall int i; 0 <= i < n ==> \old(s1[i])==s1[i];
ensures \forall int i; 0 <= i < n ==> \old(s3[i])==s3[i];
assigns s2[0..n-1];
*/
void decode(int* s1, int* s2, int* s3, int n) {
/*@
loop invariant 0 <= i <= n;
loop invariant \forall int j; 0 <= j < n ==> 0 <= s1[j] <= 26;
loop invariant \forall int i; 0 <= i < n ==> \at(s1[i],Pre)==s1[i];
loop invariant \forall int i; 0 <= i < n ==> \at(s3[i],Pre)==s3[i];
loop invariant \forall int j; 0 <= j < i ==> s2[j]==decypher(s1[j]);
loop assigns i, s2[0..n-1];
loop variant n - i;
*/
for (int i=0; i<n; i++) {
s2[i] = decypher(s1[i]);
}
}
/*@
requires n > 0;
requires \valid(s1+(0..n-1));
requires \valid(s2+(0..n-1));
requires \valid(s3+(0..n-1));
requires \forall int i1,i2,i3; 0 <= i1 < n && 0 <= i2 < n && 0 <= i3 < n ==> \separated(s1+i1,s2+i2,s3+i3);
requires \forall int i; 0 <= i < n ==> 0 <= s1[i] <= 26;
ensures \forall int i; 0 <= i < n ==> s3[i]==s1[i];
ensures \forall int i; 0 <= i < n ==> \old(s1[i])==s1[i];
assigns s2[0..n-1], s3[0..n-1];
*/
void autoencode(int* s1, int* s2, int* s3, int n) {
encode(s1, s2, s3, n);
decode(s2, s3, s1, n);
//@assert \forall int i; 0 <= i < n ==> \at(s1[i],Pre)==s1[i];
//@assert \forall int i; 0 <= i < n ==> s2[i]==cypher(s1[i]);
//@assert \forall int i; 0 <= i < n ==> s3[i]==decypher(s2[i]);
//@assert \forall int i; 0 <= i < n ==> s3[i]==decypher(cypher(s1[i]));
//@assert \forall int i; 0 <= i < n ==> s3[i]==s1[i];
}
| 95
|
/*@ predicate Swap{L1,L2}(int *a, integer i, integer j) =
@ \at(a[i],L1) == \at(a[j],L2) &&
@ \at(a[j],L1) == \at(a[i],L2) &&
@ \forall integer k; k != i && k != j
@ ==> \at(a[k],L1) == \at(a[k],L2);
@*/
/*@ predicate sorted(int *t,integer i,integer j) =
@ \forall integer k, integer l; i <= k < l <= j ==> t[k] <= t[l];
@*/
/*@ requires N>=1 && \valid(A+(0..N-1));
@ assigns A[0..N-1];
@ ensures sorted(A,0,N-1);
@*/
void selectionSort(int A[], int N)
{
int i, j, min, temp;
/*@ loop assigns i,j,min,temp, A[0..N-1];
@ loop invariant 0<=i<=N-1 && sorted(A,0,i) && (\forall integer k1, integer k2; (0<=k1<i<k2<N)==>A[k1]<=A[k2]);
@ loop variant N-i;
@*/
for (i = 0; i < N-1; i++)
{
min = i;
/*@ loop assigns j,min;
@ loop invariant i+1<=j<=N && i<=min<j && (\forall integer k; (i<=k<j)==>A[min]<=A[k]);
@ loop variant N-j;
@*/
for (j = i+1; j < N; j++){
if (A[j] < A[min]){
min = j;
}
}
if(min!=i){
temp = A[i];
A[i] = A[min];
A[min] = temp;
}
}
}
| 28
|
/*@
ensures \result == *p;
*/
int foo(int* p) {
return *p;
}
| 28
|
/*
* strnlen()
*/
#include <string.h>
/*@
requires maxlen >= 0;
requires \valid(s+(0..maxlen-1));
assigns \nothing;
behavior bigger:
assumes \forall integer i; 0 <= i < maxlen ==> s[i] != 0;
ensures \result == maxlen;
behavior smaller:
assumes \exists integer i; 0 <= i < maxlen && s[i] == 0;
ensures \result <= maxlen;
complete behaviors;
disjoint behaviors;
*/
size_t strnlen(const char *s, size_t maxlen)
{
const char *ss = s;
/* Important: the maxlen test must precede the reference through ss;
since the byte beyond the maximum may segfault */
/*@
loop invariant 0 <= maxlen <= \at(maxlen,Pre);
loop invariant \forall integer i; 0 <= i < (\at(maxlen, Pre) - maxlen) ==> s[i] != 0;
loop invariant ss == s+(\at(maxlen, Pre) - maxlen);
loop invariant s <= ss <= s+\at(maxlen, Pre);
loop assigns maxlen, ss;
loop variant maxlen;
*/
while ((maxlen > 0) && *ss) {
ss++;
maxlen--;
}
return ss - s;
}
| 21
|
/*@ requires a_valid: \valid(a);
requires b_valid: \valid(b);
ensures a_value: *a == \at(*b, Pre);
ensures b_value: *b == \at(*a, Pre);
*/
void swap(int* a, int* b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
| 8
|
/*@ requires y > 10;
@ ensures \result >= 0;
*/
int g(int y){
int x=0;
if(y>0){
x=100;
x=x+50;
x=x-100;
}else{
x = x - 150;
x=x-100;
x=x+100;
}
return x;
}
int main(){
int a = g(11);
return a;
}
| 11
|
/* run.config
COMMENT: function call
STDOPT: +"-val-builtin malloc:Frama_C_alloc_size,free:Frama_C_free -no-val-malloc-returns-null"
*/
#include <stdlib.h>
//extern void *malloc(unsigned int size);
/*@ ensures \valid(\result); */
int *f(int *x, int *y) {
*y = 1;
return x;
}
int main() {
int x = 0, *p, *q = malloc(sizeof(int)), *r = malloc(sizeof(int));
p = f(&x, q);
q = f(&x, r);
return 0;
}
| 11
|
typedef struct _list {
int i;
} *list;
/*@ requires \valid(p); */
void f(list p) {}
/*@ requires \valid(p); */
void g(struct _list* p) {}
| 4
|
#ifndef SPEC_SORTING_H
#define SPEC_SORTING_H
/*@ predicate Swap{L1,L2}(int *a, integer i, integer j) =
\at(a[i],L1) == \at(a[j],L2) &&
\at(a[j],L1) == \at(a[i],L2) &&
\forall integer k; k != i && k != j
==> \at(a[k],L1) == \at(a[k],L2);
*/
/*@ inductive Permut{L1,L2}(int *a, integer l, integer h) {
case Permut_refl{L}:
\forall int *a, integer l, h; Permut{L,L}(a, l, h);
case Permut_sym{L1,L2}:
\forall int *a, integer l, h;
Permut{L1,L2}(a, l, h) ==> Permut{L2,L1}(a, l, h);
case Permut_trans{L1,L2,L3}:
\forall int *a, integer l, h;
Permut{L1,L2}(a, l, h) && Permut{L2,L3}(a, l, h) ==>
Permut{L1,L3}(a, l, h);
case Permut_swap{L1,L2}:
\forall int *a, integer l, h, i, j;
l <= i <= h && l <= j <= h && Swap{L1,L2}(a, i, j) ==>
Permut{L1,L2}(a, l, h);
}
*/
/*@ predicate Sorted{L}(int *a, integer l, integer h) =
\forall integer i,j; l <= i <= j < h ==> a[i] <= a[j];
*/
/*@ requires \valid(t+i);
requires \valid(t+j);
assigns t[i],t[j];
ensures Swap{Old,Here}(t,i,j);
*/
void sort_swap(int t[], int i, int j)
{
int tmp = t[i];
t[i] = t[j];
t[j] = tmp;
}
#endif
| 9
|
/*@
requires \valid(a) && \valid(b);
ensures A: *a==\old(*b);
ensures B: *b==\old(*a);
assigns *a, *b;
*/
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
| 10
|
#define N 12
int array[ N ];
/*@ ensures 0 <= \result < N; */
int get_index(void);
void main()
{
int i = get_index();
array[ i ] = 3;
}
#ifndef FRAMA_C
int get_index(void)
{
int i = 7;
return i;
}
#endif
| 7
|
/*@ requires \valid(p) && \valid(q);
ensures \result >= *p && \result >= *q;
ensures \result == *p || \result == *q;
*/
int max_ptr ( int *p, int *q ) {
*p = 0;
*q = 0;
return 0 ;
}
| 6
|
struct account {
int lower_limit;
int balance;
int upper_limit;
};
/*@
predicate valid_account{L}(struct account* account) =
\valid(account) &&
account->lower_limit <= account->balance <= account->upper_limit;
*/
/*@
requires valid_account(account) &&
0<= amount <= account->upper_limit - account -> balance;
assigns account->balance;
ensures valid_account(account)
&& account->balance == \at(account->balance,Pre) + amount;
*/
void deposit(struct account* account, int amount) {
account->balance += amount;
}
/*@
requires valid_account(account) &&
0<= amount <= account -> balance -account->lower_limit;
assigns account->balance;
ensures valid_account(account)
&& account->balance == \at(account->balance,Pre) - amount;
*/
void withdraw(struct account* account, int amount) {
account->balance -= amount;
}
/*@ requires valid_account(account);
assigns \nothing;
ensures \result == account -> balance;
*/
int get_balance(struct account* account) { return account ->balance; }
/*@ requires \valid(account) && lower_limit <= 0 <= upper_limit;
assigns account->balance, account->lower_limit, account->upper_limit;
ensures valid_account(account)
&& account->balance == 0 && account->lower_limit == lower_limit
&& account->upper_limit == upper_limit;
*/
void init_account(struct account* account, int lower_limit, int upper_limit) {
account->lower_limit = lower_limit;
account -> upper_limit = upper_limit;
account->balance = 0;
}
int main () {
struct account _Account;
struct account* myAccount = &_Account;
init_account(myAccount,-100,200);
deposit(myAccount,10);
withdraw(myAccount,20);
int current_balance = get_balance(myAccount);
//@ assert current_balance == -10;
return 0;
}
| 37
|
/*@ requires \valid(a + (0..n-1));
requires \forall integer i, integer j; 0 <= i < j < n ==> a[i] <= a[j];
assigns \nothing;
ensures 0 <= \result <= n;
ensures \forall integer k; 0 <= k < \result ==> a[k] < val;
ensures \forall integer k; \result <= k < n ==> val <= a[k];
*/
unsigned lower_bound(const int *a, unsigned n, int val)
{
unsigned left = 0;
unsigned right = n;
unsigned middle = 0;
/*@ loop invariant 0 <= left <= right <= n;
loop assigns middle, left, right;
loop invariant \forall integer i; 0 <= i < left ==> a[i] < val;
loop invariant \forall integer i; right <= i < n ==> val <= a[i];
loop variant right - left;
*/
while (left < right) {
middle = left + (right - left) / 2;
if (a[middle] < val) {
//@ assert \forall integer i; 0 <= i < middle+1 ==> a[i] < val;
left = middle + 1;
} else right = middle;
}
return left;
}
/*@ requires \valid(a + (0..n-1));
requires \forall integer i, integer j; 0 <= i < j < n ==> a[i] <= a[j];
assigns \nothing;
ensures 0 <= \result <= n;
ensures \forall integer k; 0 <= k < \result ==> a[k] < val;
ensures \forall integer k; \result <= k < n ==> val <= a[k];
*/
unsigned lower_bound_raw(const int *a, unsigned n, int val)
{
unsigned i = 0;
/*@ loop invariant 0 <= i <= n;
loop invariant \forall integer j; 0 <= j < i ==> a[j] < val;
loop invariant \forall integer j; i <= j < n ==> a[j] >= a[i];
loop assigns i;
loop variant n - i;
*/
for(; i < n; ++i) {
if (a[i] >= val) {
break;
}
}
return i;
}
#ifdef OUT_OF_TASK
#include <stdio.h>
#define ARRAY_SIZE(array) (sizeof(array)/sizeof((array)[0]))
int main(void)
{
int a[] = {0};
int b[] = {0,1};
int c[] = {0,1,2,3,4,5};
int res;
res = lower_bound(a, ARRAY_SIZE(a), 0);
printf("res: %d\n", res);
res = lower_bound(b, ARRAY_SIZE(b), 1);
printf("res: %d\n", res);
res = lower_bound(c, ARRAY_SIZE(c), 10);
printf("res: %d\n", res);
}
#endif
| 33
|
/*@ predicate all_equal_in_range{L}(int *x, integer minidx, integer maxidx) =
@ \forall integer k; minidx <= k < minidx + maxidx ==> \at(x[minidx], L) == \at(x[k], L)
@ ;
*/
/*@ predicate not_equal_in_range{L}(int *x, integer minidx, integer maxidx) =
@ \exists integer k; minidx <= k < maxidx && \at(x[minidx], L) != \at(x[k], L);
*/
/*@ predicate best_is_not_best{L}(int *x, integer maxIdx, integer best) =
@ \forall integer k1; 0 <= k1 < maxIdx - best - 1 ==> all_equal_in_range{L}(x, k1, k1 + best) && (\at(x[k1], L) == \at(x[k1 + best + 1], L));
*/
/*@ predicate best_is_best{L}(int *x, integer i, integer N, integer best) =
@ \forall integer k1; (0 <= k1 < i ) ==>
@ (\forall integer j; (0 < j <= N && j + k1 <= N) && all_equal_in_range{L}(x, k1, j) ==> j <= best);
@*/
/*@ predicate all_smaller_than_best{L}(int *x, integer i, integer maxidx, integer best) =
@ \forall integer k1; (i<= k1 < maxidx && k1 + best < maxidx && (0 < k1 < maxidx ==> \at(x[k1],L) != \at(x[k1-1],L)) && all_equal_in_range{L}(x, k1, best) )
@ ==> \at(x[k1],L) != \at(x[k1+best],L);
@
@*/
/*@ requires N >= 1;
@ requires N <= 1000000;
@ requires \valid(x + (0..N-1));
@ ensures \exists integer k1; 0 <= k1 < N && all_equal_in_range(x, k1, \result);
@ ensures best_is_best(x, N, N, \result);
@ ensures \forall integer k1; (0 <= k1 < N && k1 + \result < N && all_equal_in_range(x, k1, \result)) ==> x[k1] != x[k1+\result];
@ ensures \forall integer k1; (0 <= k1 < N ==> !all_equal_in_range(x, k1, \result + 1));
@ ensures !(\exists integer k1; 0 <= k1 < N && k1 + \result < N && all_equal_in_range(x, k1, \result) && x[k1] == x[k1+\result]);
@ ensures !(\exists integer k1; 0 <= k1 < N && k1 + \result < N && all_equal_in_range(x, k1, \result+1) );
@ ensures all_smaller_than_best(x, 0, N, \result);
*/
int countSameConsecutive(int N, int x[]) {
int best = 0, i = 0;
/*@ assert i < N;
*/
/*@ loop invariant 0 <= i <= N;
@ loop invariant i == 0 ==> best == 0;
@ loop invariant i > 0 ==> 1 <= best <= N;
@ loop invariant i > 0 ==> \exists integer k1; 0 <= k1 < i && all_equal_in_range(x, k1, best);
@ loop invariant 0 < i < N ==> x[i] != x[i-1];
@ loop invariant i > 0 ==> all_smaller_than_best(x, 0, i, best);
@ loop assigns i, best;
@ loop variant N - i;
*/
while (i < N) {
int j = i+1;
/*@ loop invariant i < j <= N;
@ loop invariant all_equal_in_range(x, i, j-i);
@ loop assigns j;
@ loop variant N - j;
*/
while (j < N && x[j] == x[i]) ++j;
/*@ assert (j == N) || (x[j] != x[j-1] && !all_equal_in_range(x, i, j + 1) && x[j] != x[i]); */
/*@ assert i == 0 && j == N ==> all_equal_in_range(x, 0, N);*/
if (j-i > best) best = j-i;
/*@ assert \forall integer k; (i <= k <= j) ==> best >= k - i; */
/*@ assert best >= j - i >= 1;
*/
i = j;
}
/*@ assert best <= N;
*/
return best;
}
| 33
|
/*@ predicate is_divisor(integer m, integer n) =
(m != 0) ==> n % m == 0;
*/
/*@ predicate is_gcd(integer z, integer x1, integer x2) =
is_divisor(z, x1)
&& is_divisor(z, x2)
&& \forall integer i; is_divisor(i, x1) && is_divisor(i, x2) ==> (i <= z);
*/
/*@ axiomatic gcd {
logic integer gcd(integer a, integer b);
axiom nil:
\forall integer n; gcd(n,0) == n;
axiom next:
\forall integer a, b; gcd(b, a % b) == gcd(a,b);
lemma gcd_def:
\forall integer a, b; is_gcd(gcd(a, b), a, b);
}
*/
/*@ requires x1 > 0 && x2 > 0;
assigns \nothing;
ensures is_gcd(\result, x1, x2);
*/
unsigned gcd(unsigned x1, unsigned x2)
{
unsigned y1 = x1;
unsigned y2 = x2;
unsigned tmp = 0;
if (y1 > y2) {
y1 = x2;
y2 = x1;
}
//@ assert y1 == \min(x1, x2);
//@ assert y2 == \max(x1, x2);
/*@ loop invariant 0 <= y1 <= y2;
loop invariant y2 > 0;
loop invariant (y1 > 0) ==> gcd(x1, x2) == gcd(y1, y2);
loop invariant (y1 == 0) ==> gcd(x1, x2) == y2;
loop variant y1;
*/
while (y1 != 0) {
tmp = y1;
y1 = y2 % y1;
y2 = tmp;
}
return y2;
}
/*@ requires x1 > 0;
decreases x2;
assigns \nothing;
ensures is_gcd(\result, x1, x2);
ensures \result == gcd(x1, x2);
*/
unsigned gcd_rec(unsigned x1, unsigned x2)
{
if (x2 == 0)
return x1;
return gcd_rec(x2, x1 % x2);
}
/*@ requires x1 > 0 && x2 > 0;
assigns \nothing;
ensures is_gcd(\result, x1, x2);
*/
unsigned gcd_raw(unsigned x1, unsigned x2)
{
unsigned min = x1 > x2 ? x2 : x1;
//@ assert min == \min(x1, x2);
unsigned gcd = 1;
/*@ loop invariant 2 <= i <= min + 1;
loop invariant 1 <= gcd < i;
loop invariant is_divisor(gcd, x1);
loop invariant is_divisor(gcd, x2);
loop invariant \forall integer j; 0 <= j < i && is_divisor(j, x1) && is_divisor(j, x2) ==> (j <= gcd);
loop invariant gcd <= gcd(x1, x2);
loop assigns gcd;
loop variant min - i;
*/
for(unsigned i = 2; i <= min; ++i) {
if (x1 % i == 0 && x2 % i == 0) {
gcd = i;
}
}
return gcd;
}
#ifdef OUT_OF_TASK
#include <stdio.h>
int main(int argc, char **argv)
{
for(int i = 1; i < 1000; ++i) {
for(int j = 1; j < 1000; ++j) {
int res1 = gcd(i, j);
int res2 = gcd_rec(i, j);
int res3 = gcd_raw(i, j);
if (res1 != res2 || res2 != res3) {
printf("i: %d, j: %d, res1: %d, res2: %d, res3: %d\n", i, j, res1, res2, res3);
}
}
}
return 0;
}
#endif
| 33
|
#include <limits.h>
#include <string.h>
/*@ predicate match_w(char * x0) = ((x0[0]=='a') &&
((x0[1]=='a') &&
((x0[2]=='b') &&
((x0[3]=='a') &&
(x0[4]=='a')))));*/
/*@
assigns \nothing;
ensures \result <==> match_w(x0);
*/
int match_w(char * x0) {
char x2 = x0[0];
int x3 = x2 == 'a';
int x16;
if (x3) {
char x4 = x0[1];
int x5 = x4 == 'a';
int x15;
if (x5) {
char x6 = x0[2];
int x7 = x6 == 'b';
int x14;
if (x7) {
char x8 = x0[3];
int x9 = x8 == 'a';
int x13;
if (x9) {
char x10 = x0[4];
int x11 = x10 == 'a';
int x12;
if (x11) {
x12 = 1/*true*/;
} else {
x12 = 0/*false*/;
}
x13 = x12;
} else {
x13 = 0/*false*/;
}
x14 = x13;
} else {
x14 = 0/*false*/;
}
x15 = x14;
} else {
x15 = 0/*false*/;
}
x16 = x15;
} else {
x16 = 0/*false*/;
}
return x16;
}
/*@ predicate match_any_w(char * x17) = (\exists integer x19; (((0<=x19) &&
(x19<strlen(x17))) &&
match_w((x17+x19))));*/
/*@
requires ((strlen(x31)>=0) &&
\valid(x31+(0..(strlen(x31)+1)-1)));
assigns \nothing;
ensures ((((\result ==> match_any_w(x31)) &&
(match_any_w(x31) ==> \result)) &&
((!\result) ==> (!match_any_w(x31)))) &&
((!match_any_w(x31)) ==> (!\result)));
*/
int matcher(char * x31) {
int x33 = 0;
int x34 = 0;
/*@
loop invariant (((((((0<=x34) &&
(x34<=strlen(x31))) &&
(0<=x33)) &&
(x33<=5)) &&
((strlen(x31)>=0) &&
\valid(x31+(0..(strlen(x31)+1)-1)))) &&
(\forall int x137; (((0<=x137) &&
(x137<(x34-x33))) ==> (!match_w((x31+x137)))))) &&
(((x33==1) ==> ((x34>=1) &&
(x31[(x34-1)]=='a'))) &&
(((x33==2) ==> ((x34>=2) &&
((x31[(x34-2)]=='a') &&
(x31[(x34-1)]=='a')))) &&
(((x33==3) ==> ((x34>=3) &&
((x31[(x34-3)]=='a') &&
((x31[(x34-2)]=='a') &&
(x31[(x34-1)]=='b'))))) &&
(((x33==4) ==> ((x34>=4) &&
((x31[(x34-4)]=='a') &&
((x31[(x34-3)]=='a') &&
((x31[(x34-2)]=='b') &&
(x31[(x34-1)]=='a')))))) &&
((x33==5) ==> ((x34>=5) &&
((x31[(x34-5)]=='a') &&
((x31[(x34-4)]=='a') &&
((x31[(x34-3)]=='b') &&
((x31[(x34-2)]=='a') &&
(x31[(x34-1)]=='a'))))))))))));
loop assigns x33, x34;
loop variant ((((strlen(x31)*2)-(2*x34))+5)-x33);
*/
for (;;) {
int x35 = x34;
char x36 = x31[x35];
int x38 = x36 == '\0';
int x42;
if (x38) {
x42 = 0/*false*/;
} else {
int x39 = x33;
int x40 = x39 < 5;
x42 = x40;
}
if (!x42) break;
int x44 = x33;
int x45 = x44 == 0;
if (x45) {
int x46 = x34;
char x47 = x31[x46];
int x48 = 'a' == x47;
if (x48) {
x33 += 1;
x34 += 1;
} else {
x33 = 0;
x34 += 1;
}
} else {
int x57 = x44 == 1;
if (x57) {
int x58 = x34;
char x59 = x31[x58];
int x60 = 'a' == x59;
if (x60) {
x33 += 1;
x34 += 1;
} else {
x33 = 0;
}
} else {
int x68 = x44 == 2;
if (x68) {
int x69 = x34;
char x70 = x31[x69];
int x71 = 'b' == x70;
if (x71) {
x33 += 1;
x34 += 1;
} else {
x33 = 1;
}
} else {
int x79 = x44 == 3;
if (x79) {
int x80 = x34;
char x81 = x31[x80];
int x82 = 'a' == x81;
if (x82) {
x33 += 1;
x34 += 1;
} else {
x33 = 0;
}
} else {
int x90 = x44 == 4;
if (x90) {
int x91 = x34;
char x92 = x31[x91];
int x93 = 'a' == x92;
if (x93) {
x33 += 1;
x34 += 1;
} else {
x33 = 1;
}
} else {
}
}
}
}
}
}
int x288 = x33;
int x289 = x288 == 5;
return x289;
}
| 33
|
/*@ predicate sorted{L}(int* a, integer length) =
\forall integer i,j; 0<=i<=j<length ==> a[i]<=a[j];
*/
/*@ predicate swap{L1,L2}(int* a,integer i,integer j,integer length)=
0<=i<j<length
&& \at(a[i],L1) == \at(a[j],L2)
&& \at(a[i],L2) == \at(a[j],L1)
&& \forall integer k; 0<=k<length && k!=i && k!=j ==>
\at(a[k],L1) == \at(a[k],L2);
*/
/*@ inductive same_elements{L1,L2}(int*a , integer length) {
case refl{L}:
\forall int*a, integer length; same_elements{L,L}(a,length);
case swap{L1,L2}: \forall int*a, integer i,j,length;
swap{L1,L2}(a,i,j,length) ==> same_elements{L1,L2}(a,length);
case trans{L1,L2,L3}: \forall int*a, integer length;
same_elements{L1,L2}(a,length)
==> same_elements{L2,L3}(a,length)
==> same_elements{L1,L3}(a,length);
}
*/
/*@ requires \valid(a+(0..length-1));
requires length > 0;
assigns a[0..length-1];
behavior sorted:
ensures sorted(a,length);
behavior same_elements:
ensures same_elements{Pre,Here}(a,length);
*/
void sort (int* a, int length) {
int current;
/*@ loop invariant 0<=current<length;
loop assigns a[0..length-1],current;
for sorted: loop invariant sorted(a,current);
for sorted: loop invariant
\forall integer i,j; 0<=i<current<=j<length ==> a[i] <= a[j];
for same_elements: loop invariant
same_elements{Pre,Here}(a,length);
loop variant length-current;
*/
for (current = 0; current < length - 1; current++) {
int min_idx = current;
int min = a[current];
/*@ loop invariant current+1<=i<=length;
loop assigns i,min,min_idx;
loop invariant current<=min_idx<i;
loop invariant a[min_idx] == min;
for sorted: loop invariant
\forall integer j; current<=j<i ==> min <= a[j];
loop variant length -i;
*/
for (int i = current + 1; i < length; i++) {
if (a[i] < min) {
min = a[i];
min_idx = i;
}
}
if(min_idx != current) {
L: a[min_idx]=a[current];
a[current]=min;
/*@for same_elements:assert swap{L,Here}(a,current,min_idx,length);*/
}
}
}
| 43
|
#include <limits.h>
/*@
requires ((((((((0<x0) &&
(x0<100)) &&
(0<x1)) &&
(x1<100)) &&
(0<=x2)) &&
(0<=x3)) &&
(x2<x0)) &&
(x3<x1));
assigns \nothing;
ensures ((0<=\result) &&
(\result<(x0*x1)));
*/
int index(int x0, int x1, int x2, int x3) {
int x5 = x2 * x1;
int x6 = x5 + x3;
return x6;
}
/*@ predicate inv_matrix_Boolean(int * x26, integer x27, integer x28) = (((((x27<100) &&
(x28<100)) &&
(0<x27)) &&
(0<x28)) &&
(((x27*x28)>0) &&
\valid(x26+(0..(x27*x28)-1))));*/
/*@
requires (((((inv_matrix_Boolean(x63,x64,x65) &&
inv_matrix_Boolean(x66,x67,x68)) &&
inv_matrix_Boolean(x69,x70,x71)) &&
((x70==x64) &&
(x71==x65))) &&
((x70==x67) &&
(x71==x68))) &&
((\forall int x121; (\forall int x122; ((((0<=x121) &&
(x121<(x70*x71))) &&
((0<=x122) &&
(x122<(x64*x65)))) ==> \separated(x69+x121,x63+x122)))) &&
(\forall int x136; (\forall int x137; ((((0<=x136) &&
(x136<(x70*x71))) &&
((0<=x137) &&
(x137<(x67*x68)))) ==> \separated(x69+x136,x66+x137))))));
ensures (((inv_matrix_Boolean(x63,x64,x65) &&
inv_matrix_Boolean(x66,x67,x68)) &&
inv_matrix_Boolean(x69,x70,x71)) &&
(\forall int x157; (((0<=x157) &&
(x157<(x70*x71))) ==> (x69[x157]==(x63[x157] || x66[x157])))));
*/
void add(int * x63, int x64, int x65, int * x66, int x67, int x68, int * x69, int x70, int x71) {
/*@assert \separated(x69+0,x63+0);*/
/*@assert \separated(x69+0,x66+0);*/
int x73 = x70 * x71;
/*@
loop invariant 0<=x81<=x73;
loop invariant (\forall int x82; (((0<=x82) &&
(x82<x81)) ==> (x69[x82]==(x63[x82] || x66[x82]))));
loop assigns x81, x69[(0..x73-1)];
loop variant x73-x81;
*/
for(int x81=0; x81 < x73; x81++) {
int x94 = x63[x81];
int x95 = x66[x81];
int x96 = x94 || x95;
x69[x81] = x96;
/*@assert \separated(x69+x81,x63+x81);*/
/*@assert \separated(x69+x81,x66+x81);*/
}
}
/*@
requires (((inv_matrix_Boolean(x172,x173,x174) &&
inv_matrix_Boolean(x175,x176,x177)) &&
((x176==x173) &&
(x177==x174))) &&
(\forall int x213; (\forall int x214; ((((0<=x213) &&
(x213<(x176*x177))) &&
((0<=x214) &&
(x214<(x173*x174)))) ==> \separated(x175+x213,x172+x214)))));
ensures (((inv_matrix_Boolean(x172,x173,x174) &&
inv_matrix_Boolean(x175,x176,x177)) &&
(\forall int x233; (((0<=x233) &&
(x233<(x176*x177))) ==> (x175[x233]==(x171 &&
x172[x233]))))) &&
((x171==\false) ==> (\forall int x247; (0<=x247<x176) ==> (\forall int x250; (0<=x250<x177) ==> (x175[((x247*x177)+x250)]==\false)))));
*/
void scalar_mult(int x171, int * x172, int x173, int x174, int * x175, int x176, int x177) {
/*@assert \separated(x175+0,x172+0);*/
int x179 = x176 * x177;
/*@
loop invariant 0<=x184<=x179;
loop invariant (\forall int x185; (((0<=x185) &&
(x185<x184)) ==> (x175[x185]==(x171 &&
x172[x185]))));
loop assigns x184, x175[(0..x179-1)];
loop variant x179-x184;
*/
for(int x184=0; x184 < x179; x184++) {
int x197;
if (x171) {
int x196 = x172[x184];
x197 = x196;
} else {
x197 = 0/*false*/;
}
x175[x184] = x197;
/*@assert \separated(x175+x184,x172+x184);*/
}
}
| 54
|
/*@ requires n > 0;
requires \forall int i; 0<= i <= n-1 ==> \valid(p + i);
assigns \nothing;
ensures \forall int i; 0 <= i <= n-1 ==> \result >= p[i];
ensures \exists int i; 0 <= i <= n-1 && \result == p[i];
*/
int max_seq(int* p, int n);
int max_seq(int* p, int n) {
int res = *p;
int i;
/*@ ghost int idx = 0; */
/*@ loop invariant \forall integer j; 0 <= j <= i ==> res >= *(p+j);
loop invariant \valid(p+idx) && *(p+idx) == res;
*/
for(i = 0; i < n; i++) {
if (res < *p) {
res = *p;
/*@ ghost idx = i;*/
}
p++;
}
return res;
}
| 54
|
/*@
@ predicate canSee{L} (integer N, int *x, integer i) =
@ \forall integer j; i < j < N ==> \at(x[i], L) > \at(x[j], L);
@*/
/*@
@ predicate countTall{L} (integer N, int *x, integer i, integer c) =
@ i >= N ? c == 0 :
@ canSee{L}(N, x, i) ? countTall{L}(N, x, i + 1, c - 1)
@ : countTall{L}(N, x, i + 1, c);
@*/
/*@
@ requires N >= 1 && N <= 1000000;
@ requires \valid (x + (0 .. N -1));
@ ensures \forall integer i; 0 <= i < N ==> x[i] == \old(x[i]);
@ ensures countTall (N, x, 0, \result);
@*/
int countWhoCanSee (int N, int x[]) {
int tallest = x[N - 1];
int count = 1;
/*@
@ loop invariant -1 <= i < N -1;
@ loop invariant count + i <= N - 1;
@ loop invariant \forall integer j; i < j < N ==> tallest >= x[j];
@ loop invariant \exists integer j; i < j < N && tallest == x[j];
@ loop invariant countTall (N, x, i + 1, count);
@ loop assigns tallest, i, count;
@ loop variant i + 1;
@*/
for (int i = N - 2; i >= 0; --i)
if (tallest < x[i]) {
tallest = x[i];
count++;
}
return count;
}
| 24
|
//binary search
/*@
requires n>0;
requires \valid_read(arr+(0..n-1));
requires val>0;
behavior notfound:
assumes \forall integer nf;
0<=nf<n ==> arr[nf]!= val;
ensures \result == 0;
behavior found:
assumes \exists integer f;
0<=f<n && arr[f]==val;
ensures \result == 1;
complete behaviors;
disjoint behaviors;
*/
int Linear(int arr[], int n, int val){
/*@
loop invariant 0<=i<=n;
loop invariant \forall integer k;
0<=k<i ==> arr[k]!=val;
loop assigns i;
loop variant n-i;
*/
for(int i=0;i<n;i++){
if(val==arr[i]){
return 1;
}
}
return 0;
}
| 15
|
/*@
@ requires n > 0;
@ requires \valid(a+(0..n - 1));
@
@ assigns \nothing;
@ behavior okay_:
@ assumes \exists int i; 0 <= i < n && a[i] == val;
@ ensures 0 <= \result < n;
@ ensures \forall int i; 0 <= i < \result ==> a[i] != val;
@ ensures a[\result] == val;
@ behavior not_okay_:
@ assumes \forall int i; 0 <= i < n && a[i] != val;
@ ensures \result == n;
*/
int find(int a[], int n, int val) {
/*@
@ loop invariant 0 <= i <= n;
@ loop invariant \forall int j; 0 <= j < i ==> a[j] != val;
@ loop variant n - i;
*/
for (int i = 0; i < n; ++i) {
if (a[i] == val) return i;
}
return n;
}
| 15
|
/*@
requires \valid(a + (0..n-1));
assigns a[0..n]; // should be a[0..n-1]
*/
void foo(int* a, unsigned int n)
{
/*@
loop invariant 0 <= i <= n;
loop assigns i, a[0..n]; // should be a[0..n-1];
loop variant n-i;
*/
for(unsigned int i = 0; i < n; ++i)
a[i] = 0;
}
| 11
|
/*@
requires n > 0;
requires \forall integer i,j; 0 <= i <= j <= n-1 ==> a[i] <= a[j];
requires \valid_read(a + (0..n-1));
ensures (\forall integer k; 0 <= k <= n-1 ==> a[k] != x) || x == a[\result];
assigns \nothing;
*/
int binarysearch(int* a, int x, int n) {
int low = -1;
int high = n;
int p;
/*@
loop invariant \forall integer i,j; 0 <= i <= j <= n-1 ==> a[i] <= a[j];
loop invariant \forall integer k; 0 <= k <= low ==> a[k] < x;
loop invariant \forall integer k; high <= k <= n-1 ==> a[k] > x;
loop invariant -1 <= low+1 <= high <= n;
loop assigns low, high, p;
*/
while (low+1 < high) {
p = (low + high) / 2;
if (a[p] == x)
return p;
else
if (a[p] < x)
low = p;
else high = p;
}
return -1;
}
| 11
|
#include <limits.h>
#include <string.h>
/*@
requires ((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0))));
*/
int matcher_a_end(char * x0) {
int x2 = 0/*false*/;
int x3 = 1/*true*/;
char *x4 = x0;
/*@
loop invariant ((strlen(x4)>=0) &&
\valid(x4+(0..strlen(x4))));
loop assigns x2, x3, x4;
loop variant ((strlen(x4)+((x2) ? (0) : (1)))+((x3) ? (1) : (0)));
*/
for (;;) {
int x5 = x2;
int x9;
if (x5) {
x9 = 0/*false*/;
} else {
int x7 = x3;
x9 = x7;
}
if (!x9) break;
char *x11 = x4;
char x12 = x11[0];
int x13 = x12 == '\0';
int x16;
if (x13) {
x16 = 0/*false*/;
} else {
int x15 = 'a' == x12;
x16 = x15;
}
int x20;
if (x16) {
char *x17 = x11+1;
char x18 = x17[0];
int x19 = x18 == '\0';
x20 = x19;
} else {
x20 = 0/*false*/;
}
x2 = x20;
int x22 = x2;
if (x22) {
} else {
int x14 = !x13;
x3 = x14;
int x25 = x3;
if (x25) {
char *x17 = x11+1;
x4 = x17;
} else {
}
}
}
int x56 = x2;
return x56;
}
| 15
|
/* run.config
EXECNOW: make tests/aorai/Aorai_test.cmxs
OPT: -aorai-ltl tests/aorai/goto.ltl -aorai-test 1 -aorai-acceptance -load-module tests/aorai/Aorai_test.cmxs -aorai-test-number @PTEST_NUMBER@
*/
int status=0;
int rr=1;
//@ global invariant inv : 0<=rr<=5000;
/*@ requires rr<5000;
@ behavior j :
@ ensures rr<5001;
*/
void opa() {
rr++;
}
void opb () {
status=1;
}
void opc () {
rr=60000;
}
int main(){
if (rr<5000) goto L;
opc();
L4:
goto L5;
L:
opa();
goto L2;
opc();
L6:
return 1;
L3:
goto L4;
opc();
goto L2;
L2 :
goto L3;
L5:
opb();
goto L6;
}
| 11
|
/*@
requires 0<=first<=180 && 0<=second<=180;
ensures \result + first + second == 180;
*/
int last_angle(int first,int second){
return 180 - first - second;
}
| 6
|
#include <limits.h>
/*@
requires (x0<INT_MAX);
assigns \nothing;
ensures (\result>x0);
*/
int inc(int x0) {
int x2 = x0 + 1;
return x2;
}
| 5
|
#include <limits.h>
#include <string.h>
/*@
requires ((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0))));
*/
int matcher_a(char * x0) {
int x2 = 0/*false*/;
int x3 = 1/*true*/;
char *x4 = x0;
/*@
loop invariant ((strlen(x4)>=0) &&
\valid(x4+(0..strlen(x4))));
loop assigns x2, x3, x4;
loop variant ((strlen(x4)+((x2) ? (0) : (1)))+((x3) ? (1) : (0)));
*/
for (;;) {
int x5 = x2;
int x9;
if (x5) {
x9 = 0/*false*/;
} else {
int x7 = x3;
x9 = x7;
}
if (!x9) break;
char *x11 = x4;
char x12 = x11[0];
int x13 = x12 == '\0';
int x16;
if (x13) {
x16 = 0/*false*/;
} else {
int x15 = 'a' == x12;
x16 = x15;
}
int x18;
if (x16) {
x18 = 1/*true*/;
} else {
x18 = 0/*false*/;
}
x2 = x18;
int x20 = x2;
if (x20) {
} else {
int x14 = !x13;
x3 = x14;
int x23 = x3;
if (x23) {
char *x17 = x11+1;
x4 = x17;
} else {
}
}
}
int x54 = x2;
return x54;
}
| 14
|
#include <stdio.h>
/*@ requires a >= 0 && b > 0;
@ requires \valid(r);
@ assigns *r;
@ ensures a == b * \result + *r;
*/
int idiv(int a, int b, int *r) {
int q = 0;
int p = a;
/*@ assert a == b * q + p;*/
/*@ loop invariant a == b * q + p;
@ loop assigns q, p;
@ loop variant p;
*/
while (p >= b) {
q++;
p -= b;
}
*r = p;
return q;
}
/*
int main(int argc, char** argv) {
int r = 0;
int q = idiv(5, 2, &r);
printf("q=%d, r=%d\n", q,r );
return 0;
}*/
| 15
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.