file_content
stringlengths 65
76k
| goals
int64 1
283
|
|---|---|
/*
* @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
* 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>
#if 0
int
memcmp(const void *s1, const void *s2, size_t n)
{
if (n != 0) {
const unsigned char *p1 = s1, *p2 = s2;
do {
if (*p1++ != *p2++)
return (*--p1 - *--p2);
} while (--n != 0);
}
return (0);
}
#endif // 0
/*@
requires n >= 0;
requires n == 0 || \valid_read((char*)s1+(0..n-1));
requires n == 0 || \valid_read((char*)s2+(0..n-1));
assigns \nothing;
behavior eq:
assumes n >= 0 && \forall integer i; 0 <= i < n ==> ((const unsigned char*)s1)[i] == ((const unsigned char*)s2)[i];
ensures \result == 0;
behavior not_eq:
assumes n > 0 && \exists integer i; 0 <= i < n && ((const unsigned char*)s1)[i] != ((const unsigned char*)s2)[i];
ensures \result != 0;
complete behaviors eq, not_eq;
disjoint behaviors eq, not_eq;
*/
int memcmp(const void *s1, const void *s2, size_t n)
{
const char *c1 = s1, *c2 = s2;
int d = 0;
/*@
loop invariant 0 <= n <= \at(n, Pre);
loop invariant (char*)s1 <= c1 <= (char*)s1 + (\at(n, Pre));
loop invariant (char*)s2 <= c2 <= (char*)s2 + (\at(n, Pre));
loop invariant d == 0;
loop assigns n, c1, c2, d;
loop variant n;
*/
while (n) {
/*@ assert (char*)s1 <= c1; */
/*@ assert c1 <= (char*)s1 + (\at(n, Pre)); */
/*@ assert (char*)s2 <= c2; */
/*@ assert c2 <= (char*)s2 + (\at(n, Pre)); */
d = (int)*c1++ - (int)*c2++;
if (d)
break;
n--; //inserted code
}
return d;
}
| 34
|
/*@
requires x >= 0 && x <= __INT_MAX__ - 1;
ensures \result == x + 1;
assigns \nothing;
*/
int foo(int x) {
return x+1;
}
| 5
|
/* run.config
OPT: -load-module report -then -report
*/
/* run.config_qualif
OPT: -load-module report -then -report
EXECNOW: LOG stmt.log LOG f.dot LOG f_default_for_stmt_2.dot LOG g.dot LOG g_default_for_stmt_11.dot @frama-c@ -no-autoload-plugins -load-module wp -wp-precond-weakening -wp -wp-model Dump -wp-out tests/wp_plugin/result_qualif @PTEST_FILE@ 1> tests/wp_plugin/result_qualif/stmt.log
*/
/*@ requires a < 2147483647 && b < 2147483647 && a > -2147483648 && b > -2147483648 && a + b <= 2147483647 && a + b >= -2147483648;
@ ensures a > 0 ==> \result == a + b;
@ ensures a <= 0 ==> \result == -1;
@ assigns \nothing;
*/
int f(int a, int b) {
if (a > 0)
return a + b;
return -1;
}
/*@ requires a < 2147483647 && b < 2147483647 && a > -2147483648 && b > -2147483648 && a + b <= 2147483647 && a + b >= -2147483648;
@ ensures \result == a + b;
@ assigns \nothing;
*/
int g(int a, int b) {
return a + b;
}
/*@ ensures \result == (e ? a : b) ;
@ assigns \nothing;
@ behavior POS:
@ assumes e ;
@ ensures \result == a;
@ behavior NEG:
@ assumes !e ;
@ ensures \result == b;
@ complete behaviors POS, NEG;
@ disjoint behaviors POS, NEG;
*/
int h(int e,int a,int b) {
if (e) return a; else return b;
}
| 23
|
/*@ requires size >= 0 && \valid(t+(0..size-1));
@ assigns t[0..size-1];
@ ensures \forall integer i; 0 <= i < size ==> t[i] == 0;
@*/
void out_ecount(char *t, int size) {
int i;
/*@ loop assigns i, t[0..size-1];
loop invariant 0 <= i <= size;
loop invariant \forall integer k; 0 <= k < i ==> t[k] == 0;
loop invariant \forall integer k; i <= k < size ==> t[k] == \at(t[k], Pre);
loop variant size - i;
*/
for (i = 0; i < size; i++)
t[i] = 0;
//@ assert \forall integer k; 0 <= k < size ==> t[k] == 0;
}
| 19
|
/*@
@ requires n > 1;
@ requires \valid(a+(0..n - 1));
@
@ ensures 0 <= \result < n;
@ ensures \exists int i; 0 <= i < n && a[\result] == a[i];
@ ensures \forall int j; 0 <= j < n ==> a[\result] <= a[j];
@ assigns \nothing;
*/
int argmin(int a[], int n) {
int index_min = 0;
/*@
@ loop invariant 1 <= i <= n;
@ loop invariant 0 <= index_min < i;
@ loop invariant \forall int j; 0 <= j < i ==> a[index_min] <= a[j];
@ loop assigns index_min, i;
@ loop variant n - i;
*/
for (int i = 1; i < n; ++i) {
if (a[i] < a[index_min])
index_min = i;
}
/*@ assert \forall int j; 0 <= j < n ==> a[index_min] <= a[j]; */
return index_min;
}
| 19
|
/*@ requires n > 0;
requires \valid(p + (0..n-1));
assigns \nothing;
ensures 0 <= \result < n;
ensures \forall int i; 0 <= i < n ==> p[\result] >= p[i];
*/
int array_max(int *p, int n)
{
int max_idx = 0;
int max = p[max_idx];
/*@ loop invariant 0 <= i <= n;
loop invariant 0 <= max_idx < n;
loop invariant max == p[max_idx];
loop invariant \forall integer j; 0 <= j < i ==> p[max_idx] >= p[j];
loop invariant \forall integer j; 0 <= j < i ==> max >= p[j];
loop assigns max_idx, max, i;
loop variant n - i;
*/
for (int i = 0; i < n; i++) {
if (max < p[i]) {
max_idx = i;
max = p[i];
}
}
return max_idx;
}
| 22
|
/*@ requires
@ size > 0 && \valid(t+(0..size-1));
@ assigns \nothing;
@ ensures \result == t[size-1];
*/
char in_ecount(char *t, int size) {
return t[size -1];
}
void in_ecount_test() {
char a[] = "test";
char b = in_ecount(a, 5);
//@ assert b == '\0';
char c = in_ecount(a, 4);
//@ assert c == 't';
}
| 12
|
/* Generated by Frama-C */
#include "stdio.h"
#include "stdlib.h"
/*@ requires \valid_read(p);
requires *p == 0;
ensures \result == 0;
assigns \nothing;
*/
int f(int *p)
{
int __retres;
{
int i = 0;
/*@ loop invariant 0 <= i <= 1;
loop assigns i;
loop variant 1 - i;
*/
while (i < 1) {
i ++;
}
}
__retres = 0;
return __retres;
}
/*@ requires \valid_read(p);
requires *p == 1;
ensures \result == 0;
assigns \nothing;
*/
int g(int *p)
{
int __retres;
{
int i = 0;
/*@ loop invariant 0 <= i <= 1;
loop assigns i;
loop variant 1 - i;
*/
while (i < 1) i ++;
}
__retres = 0;
return __retres;
}
/*@ ensures \result == 0;
assigns \nothing;
*/
int main(void)
{
int __retres;
int x = 0;
int y = 1;
f(& x);
g(& y);
__retres = 0;
return __retres;
}
| 32
|
/*@ logic integer abs(integer x) = x >= 0 ? x : -x;
*/
#include<limits.h>
/*@ requires x > INT_MIN;
ensures (x >= 0 ==> \result == x) &&
(x < 0 ==> \result == -x);
assigns \nothing; */
int abs ( int x );
/*@ requires x > INT_MIN;
requires y > INT_MIN;
ensures \result >= x;
ensures \result >= y;
ensures \result == x || \result == y;
assigns \nothing; */
int max ( int x, int y );
/*@ requires x > INT_MIN;
requires y > INT_MIN;
ensures \result >= abs(x) && \result >= abs(y);
ensures \result == abs(x) ||
\result == abs(y);
assigns \nothing; */
int max_abs( int x, int y ) {
return max(abs(x),abs(y));
}
| 15
|
/*@
requires 0 < n;
requires \valid(a+(0..n-1));
assigns a[0..n-1];
ensures \forall integer i; 0 <= i < n ==> a[i] == 0;
*/
void array_zero(int* a, int n){
/*@ loop invariant 0 <= i <= n && (\forall integer k; 0 <= k < i ==> a[k] == 0);
loop assigns a[0..n-1], i;
loop variant n-i;
*/
for(int i = 0;i< n;i++){
a[i]=0;
}
}
| 13
|
/*@
@ requires n > 0;
@ requires \valid(a+(0..n-1));
@ requires \valid(b+(0..n-1));
@ assigns \nothing;
@ behavior true_:
@ assumes \forall int i; 0 <= i < n ==> a[i] == b[i];
@ ensures \result == n;
@ behavior false_:
@ assumes \exists int i; 0 <= i < n && a[i] != b[i];
@ ensures 0 <= \result < n && a[\result] != b[\result];
@ ensures \forall int i; 0 <= i < \result ==> a[i] == b[i];
@ complete behaviors true_, false_;
@ disjoint behaviors true_, false_;
*/
int compare_arrays(int a[], int b[], int n) {
/*@
@ loop invariant 0 <= i <= n;
@ loop invariant \forall integer j; 0 <= j < i ==> a[j] == b[j];
@ loop assigns i;
@ loop variant n - i;
*/
for (int i = 0; i < n; ++i) {
if (a[i] != b[i]) return i;
}
return n;
}
| 20
|
/*@ requires x > -2147483648;
@ ensures \result >= 0;
@ ensures \result == x || \result == -x;
@ assigns \nothing;
@*/
int abs(int x) {
if (x >= 0) return x;
return -x;
}
| 7
|
#include<limits.h>
/*@
requires x > 0 && x < INT_MAX;
ensures \result == x;
assigns \nothing;
*/
int test(int x) {
int a = x;
int y = 0;
/*@
loop invariant y + a == x;
loop invariant a >= 0 && a <= x;
loop assigns a, y;
loop variant a;
*/
while(a != 0) {
y = y + 1;
a = a - 1;
}
return y;
}
/*@ assigns \nothing; */
int main() {
int num = test(3);
//@ assert num == 3;
return 0;
}
| 21
|
/*@
requires 0 < n <= 10;
assigns \nothing;
ensures \result == n * (n + 1) * (2 * n + 1) / 6;
*/
int sq(int n)
{
int s;
int i;
s = 0;
i = 1;
/*@
loop invariant 1 <= i <= n + 1;
loop invariant s == (i - 1) * i * (2 * i - 1) / 6;
loop assigns s, i;
loop variant n - i;
*/
while (i <= n)
{
s = s + i * i;
i += 1;
}
return s;
}
| 18
|
/* run.config
EXECNOW: make tests/aorai/Aorai_test.cmxs
OPT: -aorai-automata tests/aorai/test_recursion5.ya -aorai-test 1 -aorai-acceptance -load-module tests/aorai/Aorai_test.cmxs -aorai-test-number @PTEST_NUMBER@
*/
//frama-c t2.c -aorai-automata t2.ya -aorai-dot -aorai-show-op-spec -aorai-output-c-file t2_annot.c
//frama-c -jessie t2_annot.c -jessie-why-opt="-fast-wp"
//#include <stdio.h>
/*@ requires \valid(t+(0..max));
@ requires max>=0;
@ requires 0<=i<=max;
@ decreases max-i;
@ ensures i<=\result<=max || \result==-1 ;
@ ensures \result!=-1 ==> t[\result]==val;
@ ensures \result==-1 ==> (\forall integer j; i<=j<=max ==> t[j]!=val);
@ assigns \nothing;
*/
int isPresentRec(int t[], int i, int max, int val) {
// printf("t : %d | s : %d | v : %d\n",t[0],size,val);
if(t[i]==val) return i;
if(max==i) return -1; // 1 de plus que max
return isPresentRec(t, i+1, max, val);
}
/*@ requires \valid(t+(0..max));
@ requires max>=0;
@ ensures 0<=\result<=max || \result==-1 ;
@ ensures \result!=-1 ==> t[\result]==val;
@ ensures \result==-1 ==> (\forall integer i; 0<=i<=max ==> t[i]!=val);
@ assigns \nothing;
*/
int isPresent(int t[], int max, int val) {
return isPresentRec(t, 0, max, val);
}
/*@ assigns \nothing; */
void foo(){}
/*@ assigns \nothing; */
int main(int argc, char** argv) {
int tab[]={10,20,33,15};
int r=isPresent(tab, 3, 33);
if (r==-1) foo();
// printf("Résultat = %d\n",r);
return 1;
}
| 40
|
#include<limits.h>
/*@
requires INT_MIN - b <= a <= INT_MAX - b;
ensures \result == a+b;
assigns \nothing;
*/
int add(int a,int b){
return a+b;
}
| 6
|
/*@
requires n > 0;
requires \valid_read(a + (0..n-1));
assigns \nothing;
behavior present:
assumes \exists integer k; 0 <= k < n && x == a[k];
ensures \result == 1;
behavior not_present:
assumes \forall integer k; 0 <= k < n ==> x != a[k];
ensures \result == 0;
complete behaviors present, not_present;
disjoint behaviors present, not_present;
*/
int arraySearch(int *a, int x, int n) {
int p = 0;
/*@
loop invariant 0 <= p <= n;
loop invariant \forall integer k; 0 <= k < p ==> x != a[k];
loop assigns p;
loop variant n - p;
*/
while (p < n) {
if (a[p] == x) {
return 1;
}
p++;
}
return 0;
}
| 18
|
/* run.config
COMMENT: \at on purely logic variables
COMMENT:
*/
/*@ assigns \nothing; */
void f(int *t) {}
/*@ assigns \nothing; */
void g() {
int m;
m = 8;
Q: ;
m = 10;
/*@ assert \exists integer w; 3 <= w < 6 && \at(m + w == 12, Q); */ ;
}
/*@ assigns \nothing; */
int main(void) {
int n;
n = 7;
L: ;
n = 9;
K: ;
n = 666;
// Predicates:
/*@ assert \let i = 3; \at(n + i == 10, L); */ ;
/*@ assert \exists integer j; 2 <= j < 5 && \at(n + j == 11, L); */ ;
/*@ assert
\let k = -7;
\exists integer u; 9 <= u < 21 &&
\forall integer v; -5 < v <= 6 ==> \at((u > 0 ? n + k : u + v) > 0, K); */ ;
// Terms:
/*@ assert \let i = 3; \at(n + i, L) == 10; */ ;
unsigned int m = 3;
G: ;
m = -3;
/*@ assert \exists integer k; -9 < k < 0 && \at(m + k, G) == 0; */ ;
/*@ assert
\exists integer u; 9 <= u < 21 &&
\forall integer v; -5 < v <= (u < 15 ? u + 6 : 3) ==> \at(n + u + v > 0, K); */ ;
// Function calls:
int t[5] = {9, 12, 12, 12, -4};
f(t);
g();
// Name capturing
/*@ assert
\exists integer u; 10 <= u < 20
&& \exists integer v; -10 < v <= -5 + (\let u = -2; u) // another u
&& \exists integer w; 10 < w <= 20
&& \at(n - u +
(\let u = 42; u) // yet another u
+ v + w > 0, K); */ ;
return 0;
}
| 28
|
/*@
requires base >= 0 && height >= 0 && base <= 2147483647 / height;
ensures \result == (base * height)/2;
assigns \nothing;
*/
int area(int base, int height){
int res = (base * height)/2;
return res;
}
/*@
assigns \nothing;
*/
int main() {
int a = area(4, 5);
//@ assert a == 10;
}
| 14
|
/*@
requires \valid(t+(0..n-1)) && n>0;
ensures (\exists integer i; 0<=i<n && t[i] == x) ==> -1<=\result<n;
ensures (\forall integer i; 0<=i<n ==> t[i] != x) ==> \result == -1;
*/
int index(int t[], int n, int x){
/*@
loop invariant 0<=i<=n;
loop invariant \forall integer j; 0<=j<i ==> t[j] != x;
loop assigns i;
loop variant n-i;
*/
for(int i=0;i<n;i++){
if(t[i] == x)
return i;
}
return -1;
}
| 13
|
#include <stdlib.h>
/*@ requires n >= 0;
requires \valid(a+(0..n-1));
requires \forall integer i, j; 0 <= i < j < n ==> a[i] <= a[j];
assigns \result \from a[0..n-1];
behavior NOT_EXISTS:
assumes \forall integer i; 0 <= i < n ==> a[i] != key;
ensures \result == \null;
behavior EXISTS:
assumes \exists integer i; 0 <= i < n && a[i] == key;
ensures \exists integer i; 0 <= i < n && \result == (a + i) && \result >= a && \result < a + n;
ensures \result != \null ==> *\result == key;
complete behaviors NOT_EXISTS, EXISTS;
disjoint behaviors NOT_EXISTS, EXISTS;
*/
int *spec_bsearch(int a[], int n, int key)
{
int left = 0;
int right = n - 1;
/*@ loop invariant 0 <= left <= n;
loop invariant -1 <= right < n;
loop invariant \forall integer i; 0 <= i < n && a[i] == key ==> left <= i <= right+1;
loop invariant (\exists integer i; 0 <= i < n && a[i] == key) ==> (\exists integer i; left <= i <= right && a[i] == key);
loop invariant right - left + 1 >= 0;
loop assigns left, right;
loop variant right - left + 1;
*/
while (left <= right) {
int m = left + (right - left) / 2;
if (a[m] < key) {
left = m + 1;
} else if (a[m] > key) {
right = m - 1;
} else {
return &a[m];
}
}
return NULL;
}
| 32
|
//In the assigns clause of g(), parameter p refers to g()'s argument, not to the global variable p.
//This problem can be circumvented using ghost variables.
typedef struct { int a; } las;
las * p;
/*@
requires \valid(p);
assigns p->a;
@*/
void f() { p->a = 5; }
/*@
requires \valid(p);
assigns p->a;
@*/
void g(int * p_arg) { f(); }
| 9
|
/*@ requires n >= 0 && \valid_range(a, 0, n - 1);
@ assigns \nothing;
@ behavior success:
@ assumes \exists integer k; 0 <= k < n && a[k] == v;
@ ensures 0 <= \result < n && a[\result] == v;
@ behavior failure:
@ assumes \forall integer k; 0 <= k < n ==> a[k] != v;
@ ensures \result == -1;
@ complete behaviors success, failure;
@ disjoint behaviors success, failure;
@*/
int search (int a[], int n, int v) {
/*@ loop invariant 0 <= i <= n;
@ loop invariant \forall integer k; 0 <= k < i ==> a[k] != v;
@ loop assigns i;
@ loop variant n - i;
@*/
for (int i = 0; i < n; i++)
if (a[i] == v)
return i;
return -1;
}
| 18
|
/*@ requires 0<=n<=1000;
ensures \result == n*(n-1)/2;
*/
int sum(int n) {
int sum=0;
/*@ loop invariant 0<=i<=n;
loop invariant sum == i*(i-1)/2;
loop assigns sum, i;
loop variant n-i;
*/
for(int i=0;i<n;i++) {
sum+=i;
}
return sum;
}
| 13
|
#include <limits.h>
/*@
requires x+y <= INT_MAX;
requires x+y >= INT_MIN;
requires x >= INT_MIN && y >= INT_MIN;
ensures \result == x+y;
assigns \nothing;
*/
int add(int x, int y) {
return x+y;
}
| 6
|
/*@
requires \valid(t+(0..taille-1)) && taille>0;
assigns \nothing;
behavior monotonic_increasing:
assumes \forall integer i; 0 <= i < taille - 1 ==> t[i] <= t[i+1];
ensures \result == 1;
behavior not_monotonic_increasing:
assumes \exists integer i; 0 <= i < taille - 1 && t[i] > t[i+1];
ensures \result == 0;
complete behaviors monotonic_increasing, not_monotonic_increasing;
disjoint behaviors monotonic_increasing, not_monotonic_increasing;
*/
int monotonic(int t[], int taille) {
/*@
loop invariant 1 <= i <= taille;
loop invariant \forall integer j; 0 <= j < i-1 ==> t[j] <= t[j+1];
loop assigns i;
loop variant taille - i;
*/
for (int i = 1; i < taille; i++) {
if (t[i] < t[i - 1])
return 0;
}
return 1;
}
| 20
|
/*@
requires n > 0;
requires \valid_read(arr + (0..n-1));
ensures \forall integer i;
0 <= i < n ==> \result <= arr[i];
*/
int arraymin(int arr[], int n) {
int min = arr[0];
/*@
loop invariant \forall integer i; 0 <= i < n ==> min <= arr[i] || i >= j;
loop invariant 1 <= j <= n;
loop assigns j, min;
loop variant n - j;
*/
for (int j=1; j<n; j++)
{
if (arr[j] < min)
min = arr[j];
}
return min;
}
| 14
|
/* run.config
EXECNOW: make tests/aorai/Aorai_test.cmxs
OPT: -aorai-ltl tests/aorai/test_boucle1.ltl -aorai-test 1 -aorai-acceptance -load-module tests/aorai/Aorai_test.cmxs -aorai-test-number @PTEST_NUMBER@
*/
int cpt=3;
//@ global invariant inv_cpt : 0<=cpt<=3;
int status=0;
//@ global invariant inv_status : 0<=status<=1;
/*@ requires \true;
@ ensures 0<=\result<=1;
@ assigns \nothing;
*/
int commit_trans() {
return 1;
}
/*@ requires \true;
@ ensures 0<=\result<=1;
@ assigns \nothing;
*/
int init_trans() {
return 1;
}
/*@ requires \true;
@ assigns cpt, status;
@ ensures \result == 0 || \result == 1;
*/
int main(){
cpt=3;
status=0;
/*@ loop assigns status, cpt;
loop invariant i :
@ 0<=status<=1
@ && 0<=cpt<=3
@ && (cpt==0 ==> status==0);
@ loop variant cpt;
*/
while (cpt>0) {
status=init_trans();
if (status && (status=commit_trans())) goto label_ok;
cpt--;
}
return 0;
label_ok:
return 1;
}
| 24
|
/*@ requires \valid(p + (0..4));
@ ensures \valid(p + (0..4));
@*/
void validPointers(int * p) {
*p = 1;
return;
}
| 4
|
#include <stdio.h>
/*@
axiomatic Factorial {
logic integer fact(integer n);
axiom case_n:
\forall integer n;
n >= 1 ==> fact(n) == n*fact(n-1);
axiom case_0:
fact(0) == 1;
}
*/
/*@
requires n >= 0 && n < 13;
ensures \result == fact(n);
assigns \nothing;
*/
int factorial(int n) {
int i = 1;
int f = 1;
/*@
loop invariant f == fact(i-1);
loop invariant 1 <= i;
loop invariant i <= n+1;
loop invariant f >= 0; // Ensure f is non-negative, useful for overflow prevention
loop assigns i, f; // other variables are invariant
loop variant n - i;
*/
while (i <= n) {
f = f * i;
i = i + 1;
}
return f;
}
| 18
|
/*@ requires \valid(p) && *p <= 100 && *p >= -100;
assigns *p;
ensures *p == \old(*p)+ 1 ; */
int incr(int *p)
{
*p = *p + 1;
return *p;
};
| 9
|
#include <stdio.h>
/*@
requires c > 0;
ensures \result == c;
assigns \nothing;
*/
int func(int c) {
int x = c;
int y = 0;
/*@
loop invariant c == x + y && x >= 0;
loop assigns x, y;
loop variant x;
*/
while(x > 0) {
x = x - 1;
y = y + 1;
}
return y;
}
| 11
|
/*@ predicate MaxElem{L}(int e, int *a, integer n) =
@ \forall integer i; 0 <= i < n ==> e >= a[i] &&
@ \exists integer i; 0 <= i < n && e == a[i];
@*/
/*@ requires n > 0 && \valid_range(a, 0, n - 1);
@ assigns \nothing;
@ ensures MaxElem(\result, a, n);
@*/
int maxelem (int a[], int n) {
int m = a[0];
/*@ loop invariant 0 < k <= n;
@ loop invariant MaxElem(m, a, k);
@ loop assigns k,m;
@ loop variant n - k;
@*/
for (int k = 1; k < n; k++)
if (a[k] > m)
m = a[k];
return m;
}
| 15
|
/*@ requires \valid(a + (0..6));
ensures \valid_read(a + (0..6)) && a[6] == '\0' &&
(a[0] == 'a') && (a[1] == 'b') && (a[2] == 'c') &&
(a[3] == 'a') && (a[4] == 'b') && (a[5] == 'c');
*/
char* strtest(char* a){
a[0] = 'a'; a[1] = 'b'; a[2] = 'c'; a[3] = 'a'; a[4] = 'b'; a[5] = 'c'; a[6] = '\0';
return a;
}
| 10
|
/*@
@ requires \valid(t+(0..n - 1));
@ requires n > 0;
@
@ ensures \forall integer i; 0 <= i < n ==> t[i] == val;
*/
void fill(int t[], int n, int val) {
/*@
@ loop invariant 0 <= i <= n;
@ loop invariant \forall integer j; 0 <= j < i ==> t[j] == val;
@ loop assigns i, t[0..n-1];
@ loop variant n - i;
*/
for (int i = 0; i < n; ++i) {
t[i] = val;
}
}
| 14
|
/*@ requires \valid(t+(0..n-1)) && 0 <= k < n;
@ ensures \forall integer i; k <= i < n ==> \result <= t[i];
@ assigns \nothing;
*/
int getMinSubarray(int t[], int n, int k) {
int res = t[k];
/*@ loop invariant k+1 <= i <= n;
@ loop invariant \forall integer j; k <= j < i ==> res <= t[j];
@ loop assigns i, res;
@ loop variant n - i;
*/
for (int i = k+1; i < n; i++)
if (t[i] < res)
res = t[i];
return res;
}
| 16
|
#ifndef __is_included__eb42c25c_df0f_11eb_ba7e_b499badf00a1
#define __is_included__eb42c25c_df0f_11eb_ba7e_b499badf00a1 1
/* Declaration of SREG */
extern volatile unsigned char SREG;
void sysclockInit();
/*@
requires \valid(&SREG);
assigns SREG;
*/
unsigned long int micros();
/*@
requires millisecs >= 0;
requires \valid(&SREG);
assigns SREG;
*/
void delay(unsigned long millisecs);
#endif /* __is_included__eb42c25c_df0f_11eb_ba7e_b499badf00a1 */
#include <stdio.h>
/* Dummy implementations to allow Frama-C to parse the code */
void sysclockInit() {}
/*@
requires \valid(&SREG);
assigns SREG;
*/
unsigned long int micros() {
SREG = 0; /* dummy assignment */
return 0;
}
/*@
requires millisecs >= 0;
requires \valid(&SREG);
assigns SREG;
*/
void delay(unsigned long millisecs) {
SREG = 0; /* dummy assignment */
}
| 9
|
int t[100];
/*@ requires \valid(t+(0..99)) && (\forall integer k ; 0 <= k < 100 ==> t[k] == 1) ;
assigns t[0..99];
ensures \valid(t+(0..99)) && (\forall integer k ; 0 <= k < 100 ==> t[k] == 2) ;
*/
void f(void)
{
int i;
/*@
loop invariant 0 <= i <= 100 && (\forall integer k ; 0 <= k < i ==> t[k] == 2)
&& (\forall integer k ; i <= k < 100 ==> t[k] == 1) ;
loop assigns t[0..99], i;
loop variant 100 - i;
*/
for (i=0; i<100; i++) t[i]++;
}
| 14
|
/*@ requires a <= 2147483647 && a >= -2147483648;
requires b <= 2147483647 && b >= -2147483648;
requires c <= 2147483647 && c >= -2147483648;
ensures \result>=a && \result>=b && \result>=c;
ensures \result==a || \result==b || \result==c;
ensures a>=b && a>=c ==> \result==a;
ensures b>=a && b>=c ==> \result==b;
ensures c>=a && c>=b ==> \result==c;
*/
int max3(int a,int b,int c) {
int max;
if((a >= b) && (a >= c)) {
max = a;
}
else if((b >= a) && (b >= c)) {
max = b;
}
else if((c >= a) && (c >= b)) {
max = c;
}
return max;
}
/*@ requires 1000>size>0;
requires \valid(t+(0..size-1));
assigns t[0..size-1];
ensures \forall integer i; 0<=i<size ==> t[i] == (i*2) ;
ensures \forall integer i; 0<=i<size-1 ==> t[i]<=t[i+1];
*/
void doubleint(int t[],int size) { // void double() --> not possible since datatype!
/*@ loop invariant 0<=i<=size;
loop invariant \forall integer j; 0<=j<i ==> t[j] == (j*2) ;
loop invariant \forall integer j; 0<=j<i-1 ==> t[j]<=t[j+1];
loop assigns i, t[0..size-1];
loop variant size-i;
*/
for(int i=0;i<size;i++) {
t[i]=i*2;
}
}
/*@ requires size>0;
requires \valid(t+(0..size-1));
assigns \nothing;
behavior success:
assumes \forall integer i; 0<=i<size-1 ==> t[i]<=t[i+1];
ensures \result==1;
behavior failure:
assumes \exists integer i; 0<=i<size-1 && t[i]>t[i+1];
ensures \result==0;
complete behaviors success, failure;
disjoint behaviors success, failure;
*/
int increasing(int t[], int size){
/*@ loop invariant 0<=i<=size;
loop invariant \forall integer j; 0<=j<i ==> t[j]<=t[j+1];
loop assigns i;
loop variant size-1-i;
*/
for(int i=0;i<size-1;i++) {
if( (t[i] > t[i+1]) ) return 0;
}
return 1;
}
| 48
|
/*@ ensures \result >= a && \result >=b && (\result == a || \result == b);
*/
int max(int a, int b) {
return a > b ? a : b;
}
| 3
|
/*@ requires n>0 && \valid(s+(0..n-1)) && \valid(t+(0..n-1));
assigns \nothing;
behavior success:
assumes \forall integer i; 0<=i<n ==> s[i]==t[i];
ensures \result == 1;
behavior failure:
assumes \exists integer i; 0<=i<n && t[i]!=s[i];
ensures \result == 0;
complete behaviors success, failure;
disjoint behaviors success, failure;
*/
int compare(int s[], int t[], int n){
/*@ loop invariant 0<=i<=n;
loop invariant \forall integer j; 0<=j<i ==> s[j]==t[j];
loop invariant i == n ==> (\forall integer k; 0<=k<n ==> s[k] == t[k]);
loop assigns i;
loop variant n-i;
*/
for(int i=0;i<n;i++){
if(s[i]!=t[i]) return 0;
}
return 1;
}
| 21
|
#include <stdio.h>
#include <limits.h>
#include <stddef.h>
#define MAX_SIZE 1000 // Define a maximum size for the array
/*@ requires validSize: MAX_SIZE > size > 0 ;
requires validArr: \valid_read(arr + (0 .. size - 1)) ;
assigns \nothing ;
ensures largest: \forall integer i; 0 <= i < size ==> \result >= arr[i] ;
ensures existsInArr: \exists integer i; 0 <= i < size && arr[i] == \result ;
*/
int arrayMax(int* arr, size_t size) {
int result = arr[0];
size_t i = 0;
/*@ loop invariant largest: \forall integer k; 0 <= k < i ==> result >= arr[k];
loop invariant pos: 0 <= i <= size;
loop invariant existsInArr: \exists integer k; 0 <= k < size && arr[k] == result ;
loop assigns i, result;
loop variant size - i;
*/
while (i < size) {
if (arr[i] > result)
result = arr[i];
i++;
}
return result;
}
| 17
|
/*@
requires \valid(a) && \valid_read(b);
requires \separated(a,b);
requires -10000000<*a<10000000 && -10000000<*b<10000000;
assigns *a;
ensures *b != 0 ==> *a==0;
ensures *b == 0 ==> *a==\old(*a);
*/
void reset_1st_if_2nd_is_true(int* a,int const* b){
if(*b){
*a =0;
//@ assert *a==0;
}
}
int main(){
int a =5, x =0;
/*@ assigns a, x; */
reset_1st_if_2nd_is_true(&a, &x);
//@ assert a == 5 ;
//@ assert x == 0 ;
int const b =1;
/*@ assigns a, x; */
reset_1st_if_2nd_is_true(&a, &b);
//@ assert a == 0 ;
//@ assert b == 1 ;
}
| 20
|
/* run.config
OPT: -rpp
*/
/*
* Based on http://sohu.io/questions/2211707/comparison-method-violates-its-general-contract
*
*/
struct NzbFile{
int* FileName;
int getFileName_toLowerCase_endsWith[5];
int Subject;
};
/*@ type invariant NzbFile_is_bool(struct NzbFile s) =
\forall integer k; 0 <= k < 5
==> (s.getFileName_toLowerCase_endsWith[k] == 0 || s.getFileName_toLowerCase_endsWith[k] == 1);*/
/*@ assigns \result \from x,y;
@ ensures x < y ==> \result == -1;
@ ensures x > y ==> \result == 1;
@ ensures x == y ==> \result == 0;
*/
int IntCompare(int x, int y){
if (x < y){
return -1;
}
if(x > y){
return 1;
}
return 0;
}
/*@ requires (o1.FileName != 0) ==> \valid_read(o1.FileName);
requires (o2.FileName != 0) ==> \valid_read(o2.FileName);
assigns \result \from o1.FileName,o1.getFileName_toLowerCase_endsWith[0..4],o1.Subject,o2.FileName,o2.getFileName_toLowerCase_endsWith[0..4],o2.Subject;
*/
int compare(struct NzbFile o1, struct NzbFile o2){
if ((o1.FileName != 0) && (o2.FileName != 0)){
if (o1.getFileName_toLowerCase_endsWith[0]) // ".nfo"
return -1000;
else if (o2.getFileName_toLowerCase_endsWith[0]) // ".nfo"
return 1000;
else if (o1.getFileName_toLowerCase_endsWith[1]) // ".sfv"
return -999;
else if (o2.getFileName_toLowerCase_endsWith[1]) // ".sfv"
return 1001;
else if (o1.getFileName_toLowerCase_endsWith[2]) // ".srr"
return -998;
else if (o2.getFileName_toLowerCase_endsWith[2]) // ".srr"
return 1002;
else if (o1.getFileName_toLowerCase_endsWith[3]) // ".nzb"
return -997;
else if (o2.getFileName_toLowerCase_endsWith[3]) // ".nzb"
return 1003;
else if (o1.getFileName_toLowerCase_endsWith[4]) //".srt"
return -996;
else if (o2.getFileName_toLowerCase_endsWith[4]) // ".srt"
return 1004;
else
return IntCompare(*o1.FileName, *o2.FileName);
}
else if ((o1.FileName != 0) && (o2.FileName == 0))
{
return -995;
}
else if ((o1.FileName == 0) && (o2.FileName != 0))
{
return 1005;
}
else
{
return IntCompare(o1.Subject, o2.Subject);
}
}
| 30
|
/*@ ghost const int MYOBJECT_MYTAB_SIZE = 5; */
#define MYOBJECT_MYTAB_SIZE 5
typedef struct MyObject{
int id;
int myTab[MYOBJECT_MYTAB_SIZE];
}MyObject;
/*@ requires \valid(self);
requires Inv1 : self->id == 0;
assigns self->id, self->myTab[0..MYOBJECT_MYTAB_SIZE-1];
ensures self->id == 0;
ensures \forall integer it_x; 0 <= it_x < MYOBJECT_MYTAB_SIZE ==> self->myTab[it_x] == 0;
*/
void test(MyObject* self){
self->id = 0;
/*@ loop invariant 0 <= i <= MYOBJECT_MYTAB_SIZE;
loop invariant \forall integer j; 0 <= j < i ==> self->myTab[j] == 0;
loop assigns i, self->myTab[0..MYOBJECT_MYTAB_SIZE-1];
loop variant MYOBJECT_MYTAB_SIZE - i;
*/
for (int i=0; i<MYOBJECT_MYTAB_SIZE;i++){
self->myTab[i] = 0;
}
}
| 19
|
/* UNSAFE because `assigns *q;` and not `assigns **q;`. */
int g = 42;
/*@
requires \valid(p) && \valid(q) && \valid(*q);
assigns *p, **q, g;
*/
void foo(int* p, int** q) {
*p = 42;
**q = 42;
g = 42;
}
| 8
|
#include <stdio.h>
#include <stdlib.h>
/*@
requires n>=0;
requires n <= 0 || \valid_read(a + (0..n-1));
assigns \nothing;
behavior sorted:
assumes n <= 1 || (\forall integer k; 0 <= k < n-1 ==> a[k] <= a[k+1]);
ensures \result == 1;
behavior not_sorted:
assumes n > 1 && (\exists integer k; 0 <= k < n-1 && a[k] > a[k+1]);
ensures \result == 0;
complete behaviors sorted, not_sorted;
disjoint behaviors sorted, not_sorted;
*/
int arraySorted(int a[], int n){
int i = 0;
if (n <= 1) return 1;
/*@
loop invariant 0 <= i <= n;
loop invariant \forall integer k; 0 <= k < i ==> a[k] <= a[k+1];
loop assigns i;
loop variant n - i;
*/
while (i < n-1){
/*@ assert i < n; */
if(a[i] > a[i+1]){
return 0;
}
i = i + 1;
}
return 1;
}
/*@ assigns \nothing; */
int main(){
int a[] = {1,2,3,4,5};
int n = 5;
arraySorted(a,n);
return 0;
}
| 30
|
/*@ requires a < 2147483647 && a >= -1;
ensures (a >= 0) ==> (\result == a + 1);
ensures (a < 0) ==> (\result == 0);
*/
int plus_one(int a) {
if (a >= 0) {
return a + 1;
} else {
return 0;
}
}
| 5
|
/* Generated by Frama-C */
/*@ ensures \result == 0;
assigns \nothing; */
int f(int x)
{
x = 0;
return x;
}
int Y = 1;
/*@ ensures \result == Y;
assigns \nothing; */
int g(int x)
{
return Y;
}
/*@ ensures \result == 0;
assigns \nothing; */
int h(void)
{
int __retres;
__retres = 0;
return __retres;
}
/*@ assigns \nothing; */
int main(void)
{
int __retres;
__retres = 0;
return __retres;
}
| 15
|
int x;
//@ predicate p(integer n) = n > 0 ;
//@ predicate p_array(int t[]) = t[0];
/*@ axiomatic Q {
@ predicate q(int t[]);
@
@ axiom q_ax: \forall int t[]; t[0] == 0 ==> q(t);
@ } @*/
/*@ assigns x; */
void f() {
/*@ ghost */ int i = 0;
/*@ loop assigns i;
loop invariant i >= 0;
loop variant 100 - i;
*/
for (;;) {
if(i > 99) break;
i++;
}
/*@ ghost */ i = 0;
/*@ loop assigns x, i;
loop invariant i >= 0;
loop variant 100 - i;
*/
for(;;) {
L2: x = 0;
if(i > 99) break;
i++;
}
L1: x = 0;
}
| 18
|
#include <limits.h>
/*@ requires x != INT_MIN;
assigns \nothing;
ensures x >= 0 ==> \result == x;
ensures x < 0 ==> \result == -x;
*/
int abs(int x) {
if (x < 0)
return -x;
else
return x;
}
/*@
assigns \nothing;
*/
int main() {
abs(10);
abs(-20);
return 0;
}
| 14
|
/*@ axiomatic GCD {
logic integer GCD(integer x, integer y);
axiom gcd_pos:
\forall integer x, y; x > 0 && y > 0 ==> GCD(x, y) > 0;
axiom gcd_recursive:
\forall integer x, y; x > 0 && y > 0 ==> GCD(x, y) == (x == y ? x : (x > y ? GCD(x - y, y) : GCD(x, y - x)));
}*/
/*@ requires x > 0 && y > 0;
@ ensures \result == GCD(x,y);
@ assigns \nothing;
*/
int gcd(int x, int y){
int a = x;
int b = y;
/*@ loop assigns a,b;
@ loop invariant a > 0;
@ loop invariant b > 0;
@ loop invariant GCD(a,b) == GCD(x,y);
@ loop variant a*b;
*/
while(a != b){
if(a > b){
a = a - b;
}
else{
b = b - a;
}
}
return a;
}
| 17
|
/*@ requires \valid(t+(0..n-1)) && n>0;
ensures 0<=\result<n;
ensures \forall integer i; 0<=i<n ==> t[\result] <= t[i];
*/
int minIndex(int t[], int n){
int index=0;
/*@ loop invariant 0<=i<=n;
loop invariant 0<=index<n;
loop invariant \forall integer j; 0<=j<i ==> t[index] <= t[j];
loop assigns index,i;
loop variant n-i;
*/
for(int i=0;i<n;i++){
if(t[i]<t[index]) {
index=i;
}
}
return index;
}
| 16
|
#include <limits.h>
/*@
requires
0 < x0 && x0 < 100 &&
0 < x1 && x1 < 100 &&
\valid(x2 + (0..(x0 * x1) - 1)) &&
(\forall integer i; 0 <= i < (x0 * x1) ==> 0 <= x2[i] < 256);
assigns x2[0..(x0*x1)-1];
ensures \forall integer i; 0 <= i < (x0 * x1) ==> x2[i] == 7;
*/
void p(int x0, int x1, int * x2) {
/*@
loop invariant 0<=x5<=x0;
loop invariant (\forall integer i; 0 <= i < (x5 * x1) ==> x2[i] == 7);
loop invariant (\forall integer i; (x5 * x1) <= i < (x0 * x1) ==> 0 <= x2[i] < 256);
loop assigns x5, x2[0..(x0*x1)-1];
loop variant x0-x5;
*/
for(int x5=0; x5 < x0; x5++) {
int x11 = x5 * x1;
/*@
loop invariant 0<=x13<=x1;
loop invariant (x11==(x5*x1));
loop invariant (\forall integer i; 0 <= i < (x5 * x1 + x13) ==> x2[i] == 7);
loop invariant (\forall integer i; (x5 * x1 + x13) <= i < (x0 * x1) ==> (0 <= x2[i] < 256 || x2[i] == 7));
loop assigns x13, x2[0..(x0*x1)-1];
loop variant x1-x13;
*/
for(int x13=0; x13 < x1; x13++) {
int x42 = x11 + x13;
int x43 = x2[x42];
x2[x42] = 7;
//@ assert x2[x42] == 7;
}
}
}
| 37
|
/*@ lemma mean : \forall integer x, y; x <= y ==> x <= (x+y)/2 <= y; */
/*@ requires n >= 0 && \valid(t+(0..n-1));
@ ensures -1 <= \result <= n-1;
@ assigns \nothing;
@*/
int binary_search4(int* t, int n, int v) {
int l = 0, u = n-1, p = -1;
/*@ loop invariant
@ 0 <= l && u < n && -1 <= p <= n-1;
@ loop invariant \forall integer i; l <= i <= u ==> \valid_read(t+i);
@ loop assigns l, u, p;
@ loop invariant l <= u+1;
@ loop variant u - l;
@*/
while (l <= u) {
int m = l + (u - l) / 2;
if (t[m] < v)
l = m + 1;
else if (t[m] > v)
u = m - 1;
else {
p = m; break;
}
}
return p;
}
| 24
|
/*@
requires -10 <= x <= 0 ;
requires 0 <= y <= 5 ;
ensures -5 <= \result <= 10 ;
assigns \nothing;
*/
int function(int x, int y) {
int res ;
y += 10 ;
x -= 5 ;
res = x + y ;
//@ assert -15 <= res <= 15;
return res ;
}
| 11
|
/*@
requires -100 <= n <= 1000; // Added a reasonable range for n
decreases n > 100 ? 0 : 101 - n; // Added decreases clause
assigns \nothing;
ensures ((n <= 100) ==> (\result == 91));
ensures ((n > 100) ==> (\result == (n-10)));
*/
int foo(int n) {
if (n > 100) {
return n - 10;
} else {
return foo(foo(n + 11));
}
}
| 17
|
/* run.config
OPT: -rpp
*/
/*
* Based on http://stackoverflow.com/questions/26336978/comparison-method-violates-its-general-contract-and-method-compareto
*
*/
struct Contact{
int getFirstName;
int getLastName;
int getEmails;
};
/*@ assigns \result \from x,y;
@ ensures x < y ==> \result == -1;
@ ensures x > y ==> \result == 1;
@ ensures x == y ==> \result == 0;
*/
int IntCompare(int x, int y){
if (x < y){
return -1;
}
if(x > y){
return 1;
}
return 0;
}
/*@ assigns \result \from o1,o2;
*/
int compare(struct Contact o1, struct Contact o2) {
int compareFirstName = 0;
if ((o1.getFirstName != 0) && (o2.getFirstName != 0)) {
compareFirstName = IntCompare(o1.getFirstName, o2.getFirstName);
if (compareFirstName == 0) {
int compareLastName = 0;
if ((o1.getLastName != 0) && (o2.getLastName != 0)) {
compareLastName = IntCompare(o1.getLastName, o2.getLastName);
if (compareLastName == 0) {
int compareEmail = 0;
if ((o1.getEmails != 0) && (o2.getEmails != 0)) {
compareEmail = IntCompare(o1.getEmails, o2.getEmails);
return compareEmail;
} else {
return 0;
}
} else {
return compareLastName;
}
} else {
int compareEmail = 0;
if ((o1.getEmails != 0) && (o2.getEmails != 0)) {
compareEmail = IntCompare(o1.getEmails, o2.getEmails);
return compareEmail;
} else {
return 0;
}
}
} else {
return compareFirstName;
}
} else {
int compareLastName = 0;
if ((o1.getLastName != 0) && (o2.getLastName != 0)) {
compareLastName = IntCompare(o1.getLastName, o2.getLastName);
if (compareLastName == 0) {
int compareEmail = 0;
if ((o1.getEmails != 0) && (o2.getEmails != 0)) {
compareEmail = IntCompare(o1.getEmails, o2.getEmails);
return compareEmail;
} else {
return 0;
}
} else {
return compareLastName;
}
} else {
int compareEmail = 0;
if ((o1.getEmails != 0) && (o2.getEmails != 0)) {
compareEmail = IntCompare(o1.getEmails, o2.getEmails);
return compareEmail;
} else {
return 0;
}
}
}
}
| 33
|
#include<limits.h>
/*@ requires x >= 0 || x > INT_MIN;
assigns \nothing;
behavior pos:
assumes x >= 0;
ensures \result == x;
behavior neg:
assumes x < 0;
ensures \result == -x;
complete behaviors pos, neg;
//disjoint behaviors pos, neg; // removed because x == 0 makes both pos and neg true.
*/
int abs ( int x ) {
if ( x >=0 )
return x ;
return -x ;
}
| 8
|
/*@
@ requires \valid(p);
@ requires \valid(q);
@ requires -1000 <= *p <= 10000;
@ requires -1000 <= *q <= 10000;
@ assigns *p, *q;
@ ensures *p == \old(*q);
@ ensures *q == \old(*p);
*/
void swap(int *p, int *q) {
int temp = *p;
*p = *q;
*q = temp;
}
| 10
|
#include <limits.h>
/*@
requires x != INT_MIN;
assigns \nothing;
ensures x >= 0 ==> \result == x;
ensures x < 0 ==> \result == -x;
*/
int abs(int x) {
if (x >= 0) {
return x;
} else {
return -x;
}
}
| 7
|
/* run.config
OPT: -rpp
*/
/*@ requires \valid(t+(0..n-1));
@ requires n >= 1;
@ requires \forall integer k; 0 <= k < n ==> 0 <= t[k];
@ ensures \forall integer k; 0 <= k < n ==> \result >= t[k];
@ ensures \exists integer k; 0 <= k < n && \result == t[k];
@ assigns \nothing;
*/
int f(int t[], int n){
int max = t[0];
int i = 0;
/*@ loop assigns i,max;
@ loop invariant 0 <= i <= n;
@ loop invariant \forall integer k; 0 <= k < i ==> max >= t[k];
@ loop invariant \exists integer k; 0 <= k < n && max == t[k];
@ loop variant n-i;
*/
while(i < n){
if(t[i] > max){
max = t[i];
}
i++;
}
return max;
}
| 18
|
/*@
requires n>0;
requires \valid_read(a+(0..n-1));
ensures \forall integer k; 0<=k<n ==> \result>=a[k];
*/
int max(int a[], int n){
int m=a[0];
/*@
loop invariant \forall integer j; 0<=j<i ==> m>=a[j];
loop invariant 1<=i<=n;
loop assigns i,m;
loop variant n-i;
*/
for(int i=1;i<n;i++){
if(m<a[i]){
m=a[i];
}
}
return m;
}
| 14
|
/*@ requires 0<x<=100 && 0<y<=100;
ensures \result == x*y;
ensures 0<\result<=10000;
assigns \nothing;
*/
int mul(int x, int y){
int mul=0;
/*@
loop invariant 0<=i<=y;
loop invariant mul==x*i;
loop assigns mul,i;
loop variant y-i;
*/
for(int i=0;i<y;i++)
mul+=x;
return mul;
}
| 15
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.