[kernel] Parsing share/libc/__fc_builtin_for_normalization.i (no preprocessing)
[kernel] Parsing tests/spec/bts1068.i (no preprocessing)
tests/spec/bts1068.i:53:[kernel] warning: parsing obsolete ACSL construct '\valid_index(addr,idx)'. '\valid(addr+idx)' should be used instead.
tests/spec/bts1068.i:54:[kernel] warning: parsing obsolete ACSL construct '\valid_range(addr,min,max)'. '\valid(addr+(min..max))' should be used instead.
tests/spec/bts1068.i:87:[kernel] warning: inductive predicate model_2 needs a label. Ignoring global annotation
tests/spec/bts1068.i:111:[kernel] warning: inductive predicate model_6 needs a label. Ignoring global annotation
/* Generated by Frama-C */
struct __anonstruct_S_1 {
   int a ;
   unsigned char *b ;
};
typedef struct __anonstruct_S_1 S;
struct __anonstruct_T_2 {
   int a ;
   unsigned char b[10] ;
};
typedef struct __anonstruct_T_2 T;
struct _list {
   int element ;
   struct _list *next ;
};
typedef struct _list list;
int *P;
int V;
int Tab[10];
/*@
axiomatic A {
  logic T t
    reads \nothing;
  
  logic ℤ ft(T x) = x.b[1];
  
  logic ℤ ft2(T x) 
    reads x.b[1];
  
  predicate PT(T x) = x.b[1] > 1;
  
  predicate PT2(T x) 
    reads x.b[1];
  
  axiom T1: t.a ≡ 0;
  
  axiom T2: t.b[0] ≡ 0;
  
  axiom T3: PT(t) ⇒ PT2(t);
  
  logic S s
    reads \nothing;
  
  logic ℤ fs{L}(S x) = \at(*(x.b+1),L);
  
  logic ℤ fs2{L}(S x) 
    reads \at(*(x.b+1),L);
  
  predicate PS{L}(S x) = \at(*(x.b+1) > 1,L);
  
  predicate PS2{L}(S x) 
    reads \at(*(x.b+1),L);
  
  axiom S1: s.a ≡ 0;
  
  axiom S2{L}: *(s.b+0) ≡ 0;
  
  axiom S3{L}: PS{L}(s) ⇒ PS2{L}(s);
  
  logic ℤ p{L}
    reads \at(*P,L);
  
  logic int * va{L}
    reads \at(&V,L);
  
  logic ℤ v{L}
    reads V;
  
  logic int * fa(int *q) = q;
  
  logic int fa2{L}(int *q) = \at(*q,L);
  
  logic char * fa3{L}(ℤ i) = \at((char *)(&P)+i,L);
  
  logic ℤ fa4{L}(T *q) 
    reads \at(q->a,L);
  
  predicate Initialized{L}(int *q) = \at(\initialized{L}(q),L);
  
  predicate Valid{L}(int *q) = \at(\valid{L}(q),L);
  
  predicate ValidIndex{L}(int *q) = \at(\valid{L}(q+1),L);
  
  predicate ValidRange{L}(int *q) = \at(\valid{L}(q+(0 .. 2)),L);
  
  predicate Separated(int *a, int *b) = \separated(a, b);
  
  logic ℤ BlockLength{L}(int *q) = \at(\block_length(q),L);
  
  logic char * Base_addr{L}(int *q) = \at(\base_addr(q),L);
  
  logic ℤ fi{L}(T *t) = \at(t->a+t->a,L);
  
  }
 */
/*@ type List<A> = Nil | Cons(A, List<A> );
 */
/*@
inductive model_0{L1, L2}(list *root, List<int>  logic_list) {
  case nil{L1, L2}: model_0{L1, L2}(\null, Nil);
  case cons{L1, L2}: ∀ list *l1, List<int>  ll1;
                       \at(\valid{L1}(l1),L1) ⇒
                       model_0{L1, L2}(\at(l1->next,L1), ll1) ⇒
                       model_0{L1, L2}(l1, Cons(\at(l1->element,L1), ll1));
  }
 */
/*@
inductive model_1{L}(list *root, List<int>  logic_list) {
  case nil{L}: \at(model_1{L}(\null, Nil),L);
  case cons{L}: \at(∀ list *l1, List<int>  ll1;
                      \valid{L}(l1) ⇒
                      model_1{L}(\at(l1->next,L), ll1) ⇒
                      model_1{L}(l1, Cons(\at(l1->element,L), ll1)),
                    L);
  }
 */
/*@
inductive model_3{L}(list *root, List<int>  logic_list) {
  case nil{L}: \at(model_3{L}(\null, Nil),L);
  case cons{L}: \at(∀ list *l1, List<int>  ll1;
                      \valid{L}(l1) ⇒
                      model_3{L}(l1->next, ll1) ⇒
                      model_3{L}(l1, Cons(l1->element, ll1)),
                    L);
  }
 */
/*@
inductive model_4{L1}(list *root, List<int>  logic_list) {
  case nil{L}: \at(model_4{L}(\null, Nil),L);
  case cons{L1}: \at(∀ list *l1, List<int>  ll1;
                       \valid{L1}(l1) ⇒
                       model_4{L1}(l1->next, ll1) ⇒
                       model_4{L1}(l1, Cons(l1->element, ll1)),
                     L1);
  }
 */
/*@
inductive model_5{L}(list *root, List<int>  logic_list) {
  case nil{L}: \at(model_5{L}(\null, Nil),L);
  case cons{L1}: \at(∀ list *l1, List<int>  ll1;
                       \valid{L1}(l1) ⇒
                       model_5{L1}(l1->next, ll1) ⇒
                       model_5{L1}(l1, Cons(l1->element, ll1)),
                     L1);
  }
 */
/*@
inductive model_7{L1}(list *root, List<int>  logic_list) {
  case nil{L1}: \at(model_7{L1}(\null, Nil),L1);
  case cons{L}: \at(∀ list *l1, List<int>  ll1;
                      \valid{L}(l1) ⇒
                      model_7{L}(l1->next, ll1) ⇒
                      model_7{L}(l1, Cons(l1->element, ll1)),
                    L);
  }
 */
/*@
inductive model_8{L1}(list *root, List<int>  logic_list) {
  case nil{L}: \at(model_8{L}(\null, Nil),L);
  case cons{L}: \at(∀ list *l1, List<int>  ll1;
                      \valid{L}(l1) ⇒
                      model_8{L}(l1->next, ll1) ⇒
                      model_8{L}(l1, Cons(l1->element, ll1)),
                    L);
  }
 */
/*@
inductive model_9{L1, L2}(list *root, List<int>  logic_list) {
  case nil{L}: \at(\valid{L}(P),L);
  }
 */

