void atp_NORMAL_computeAverageAccel(ArrayInt *Accel, int *AverageAccel)
{
__e_acsl_store_block((void *)(& AverageAccel),(size_t)8);
__e_acsl_store_block((void *)(& Accel),(size_t)8);
__e_acsl_initialize((void *)AverageAccel,sizeof(int));
*AverageAccel = (((((*Accel)[4] + (*Accel)[3]) + (*Accel)[2]) + (*Accel)[1]) + (*Accel)[0]) / 5;
__e_acsl_delete_block((void *)(& AverageAccel));
__e_acsl_delete_block((void *)(& Accel));
return;
}
int main(void)
{
int __retres;
int *p;
int *q;
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
__e_acsl_globals_init();
__e_acsl_store_block((void *)(& q),(size_t)8);
__e_acsl_store_block((void *)(& p),(size_t)8);
int counter = 0;
size_t limit = (unsigned long)10000;
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_full_init((void *)(& p));
p = (int *)malloc((unsigned long)(1024 * 1024));
__e_acsl_temporal_store_nblock((void *)(& p),(void *)*(& p));
__e_acsl_temporal_store_nreferent((void *)(& q),(void *)(& p));
__e_acsl_full_init((void *)(& q));
q = p;
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_temporal_save_nreferent_parameter((void *)(& p),0U);
free((void *)p);
while ((size_t)counter < limit) {
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_full_init((void *)(& p));
p = (int *)malloc((unsigned long)(1024 * 1024));
__e_acsl_temporal_store_nblock((void *)(& p),(void *)*(& p));
counter ++;
/*@ assert Eva: dangling_pointer: ¬\dangling(&q); */
if (p != q) {
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_temporal_save_nreferent_parameter((void *)(& p),0U);
free((void *)p);
}
else {
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_temporal_save_nreferent_parameter((void *)(& p),1U);
__gen_e_acsl_printf_va_1(__gen_e_acsl_literal_string,(void *)p,counter);
break;
}
__e_acsl_temporal_store_nblock((void *)(& p),(void *)0);
__e_acsl_full_init((void *)(& p));
p = (int *)0;
}
/*@ assert Eva: dangling_pointer: ¬\dangling(&p); */
if (p) {
/*@ assert Eva: dangling_pointer: ¬\dangling(&q); */
__e_acsl_initialize((void *)q,sizeof(int));
/*@ assert Eva: mem_access: \valid(q); */
*q = 1;
__e_acsl_initialize((void *)p,sizeof(int));
*p = 2;
}
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_temporal_save_nreferent_parameter((void *)(& p),0U);
free((void *)p);
__retres = 0;
__e_acsl_delete_block((void *)(& q));
__e_acsl_delete_block((void *)(& p));
__e_acsl_memory_clean();
return __retres;
}
int main(int argc, char **argv)
{
int __retres;
__e_acsl_memory_init(& argc,& argv,(size_t)8);
__e_acsl_globals_init();
int *p = (int *)0;
__e_acsl_store_block((void *)(& p),(size_t)8);
__e_acsl_full_init((void *)(& p));
int *q = (int *)0;
int a = 1;
int b = 2;
__e_acsl_store_block((void *)(& b),(size_t)4);
__e_acsl_full_init((void *)(& b));
int c = 3;
__e_acsl_full_init((void *)(& p));
p = & b;
/*@ assert \valid(p); */
{
int __gen_e_acsl_initialized;
int __gen_e_acsl_and;
__gen_e_acsl_initialized = __e_acsl_initialized((void *)(& p),
sizeof(int *));
if (__gen_e_acsl_initialized) {
int __gen_e_acsl_valid;
__gen_e_acsl_valid = __e_acsl_valid((void *)p,sizeof(int),(void *)p,
(void *)(& p));
__gen_e_acsl_and = __gen_e_acsl_valid;
}
else __gen_e_acsl_and = 0;
__e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",(char *)"main",
(char *)"\\valid(p)",24);
}
/*@ assert ¬\valid(p + 1); */
{
int __gen_e_acsl_valid_2;
__gen_e_acsl_valid_2 = __e_acsl_valid((void *)(p + 1),sizeof(int),
(void *)p,(void *)(& p));
__e_acsl_assert(! __gen_e_acsl_valid_2,(char *)"Assertion",
(char *)"main",(char *)"!\\valid(p + 1)",26);
}
__e_acsl_full_init((void *)(& p));
p = & B;
/*@ assert \valid(p); */
{
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_2;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& p),
sizeof(int *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_valid_3;
__gen_e_acsl_valid_3 = __e_acsl_valid((void *)p,sizeof(int),(void *)p,
(void *)(& p));
__gen_e_acsl_and_2 = __gen_e_acsl_valid_3;
}
else __gen_e_acsl_and_2 = 0;
__e_acsl_assert(__gen_e_acsl_and_2,(char *)"Assertion",(char *)"main",
(char *)"\\valid(p)",29);
}
/*@ assert ¬\valid(p + 1); */
{
int __gen_e_acsl_valid_4;
__gen_e_acsl_valid_4 = __e_acsl_valid((void *)(p + 1),sizeof(int),
(void *)p,(void *)(& p));
__e_acsl_assert(! __gen_e_acsl_valid_4,(char *)"Assertion",
(char *)"main",(char *)"!\\valid(p + 1)",31);
}
char *pmin = malloc(sizeof(int));
__e_acsl_store_block((void *)(& pmin),(size_t)8);
__e_acsl_full_init((void *)(& pmin));
char *pmax = malloc(sizeof(int));
__e_acsl_store_block((void *)(& pmax),(size_t)8);
__e_acsl_full_init((void *)(& pmax));
if ((unsigned long)pmin > (unsigned long)pmax) {
char *t = pmin;
__e_acsl_store_block((void *)(& t),(size_t)8);
__e_acsl_full_init((void *)(& t));
__e_acsl_full_init((void *)(& pmin));
pmin = pmax;
__e_acsl_full_init((void *)(& pmax));
pmax = t;
__e_acsl_delete_block((void *)(& t));
}
__e_acsl_initialize((void *)pmin,sizeof(char));
/*@ assert Eva: mem_access: \valid(pmin); */
*pmin = (char)'P';
__e_acsl_initialize((void *)pmax,sizeof(char));
/*@ assert Eva: mem_access: \valid(pmax); */
*pmax = (char)'L';
int diff = (int)((unsigned long)pmax - (unsigned long)pmin);
/*@ assert \valid(pmin); */
{
int __gen_e_acsl_initialized_3;
int __gen_e_acsl_and_3;
__gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& pmin),
sizeof(char *));
if (__gen_e_acsl_initialized_3) {
int __gen_e_acsl_valid_5;
__gen_e_acsl_valid_5 = __e_acsl_valid((void *)pmin,sizeof(char),
(void *)pmin,(void *)(& pmin));
__gen_e_acsl_and_3 = __gen_e_acsl_valid_5;
}
else __gen_e_acsl_and_3 = 0;
__e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion",(char *)"main",
(char *)"\\valid(pmin)",49);
}
/*@ assert \valid(pmax); */
{
int __gen_e_acsl_initialized_4;
int __gen_e_acsl_and_4;
__gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& pmax),
sizeof(char *));
if (__gen_e_acsl_initialized_4) {
int __gen_e_acsl_valid_6;
__gen_e_acsl_valid_6 = __e_acsl_valid((void *)pmax,sizeof(char),
(void *)pmax,(void *)(& pmax));
__gen_e_acsl_and_4 = __gen_e_acsl_valid_6;
}
else __gen_e_acsl_and_4 = 0;
__e_acsl_assert(__gen_e_acsl_and_4,(char *)"Assertion",(char *)"main",
(char *)"\\valid(pmax)",50);
}
/*@ assert ¬\valid(pmin + diff); */
{
int __gen_e_acsl_valid_7;
__gen_e_acsl_valid_7 = __e_acsl_valid((void *)(pmin + diff),sizeof(char),
(void *)pmin,(void *)(& pmin));
__e_acsl_assert(! __gen_e_acsl_valid_7,(char *)"Assertion",
(char *)"main",(char *)"!\\valid(pmin + diff)",52);
}
/*@ assert ¬\valid(pmax - diff); */
{
int __gen_e_acsl_valid_8;
__gen_e_acsl_valid_8 = __e_acsl_valid((void *)(pmax - diff),sizeof(char),
(void *)pmax,(void *)(& pmax));
__e_acsl_assert(! __gen_e_acsl_valid_8,(char *)"Assertion",
(char *)"main",(char *)"!\\valid(pmax - diff)",54);
}
__retres = 0;
__e_acsl_delete_block((void *)(& B));
__e_acsl_delete_block((void *)(& pmax));
__e_acsl_delete_block((void *)(& pmin));
__e_acsl_delete_block((void *)(& b));
__e_acsl_delete_block((void *)(& p));
__e_acsl_memory_clean();
return __retres;
}
int main(void)
{
int __retres;
temporal t1;
temporal t2;
temporal *tp;
temporal tarr[2];
larger l;
larger *lp;
larger larr[2];
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
__e_acsl_store_block((void *)(larr),(size_t)64);
__e_acsl_store_block((void *)(& lp),(size_t)8);
__e_acsl_store_block((void *)(& l),(size_t)32);
__e_acsl_store_block((void *)(tarr),(size_t)32);
__e_acsl_store_block((void *)(& t2),(size_t)16);
__e_acsl_store_block((void *)(& t1),(size_t)16);
int a = 1;
__e_acsl_store_block((void *)(& a),(size_t)4);
__e_acsl_full_init((void *)(& a));
int b = 2;
__e_acsl_temporal_store_nblock((void *)(& t1.p),(void *)(& a));
__e_acsl_initialize((void *)(& t1.p),sizeof(char *));
t1.p = (char *)(& a);
__e_acsl_temporal_store_nreferent((void *)(& t1.q),(void *)(& t1.p));
__e_acsl_initialize((void *)(& t1.q),sizeof(char *));
t1.q = t1.p;
/*@ assert \valid(t1.p) ∧ \valid(t1.q); */
{
int __gen_e_acsl_initialized;
int __gen_e_acsl_and;
int __gen_e_acsl_and_3;
__gen_e_acsl_initialized = __e_acsl_initialized((void *)(& t1.p),
sizeof(char *));
if (__gen_e_acsl_initialized) {
int __gen_e_acsl_valid;
__gen_e_acsl_valid = __e_acsl_valid((void *)t1.p,sizeof(char),
(void *)t1.p,(void *)(& t1.p));
__gen_e_acsl_and = __gen_e_acsl_valid;
}
else __gen_e_acsl_and = 0;
if (__gen_e_acsl_and) {
int __gen_e_acsl_initialized_2;
int __gen_e_acsl_and_2;
__gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& t1.q),
sizeof(char *));
if (__gen_e_acsl_initialized_2) {
int __gen_e_acsl_valid_2;
__gen_e_acsl_valid_2 = __e_acsl_valid((void *)t1.q,sizeof(char),
(void *)t1.q,(void *)(& t1.q));
__gen_e_acsl_and_2 = __gen_e_acsl_valid_2;
}
else __gen_e_acsl_and_2 = 0;
__gen_e_acsl_and_3 = __gen_e_acsl_and_2;
}
else __gen_e_acsl_and_3 = 0;
__e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion",(char *)"main",
(char *)"\\valid(t1.p) && \\valid(t1.q)",31);
}
/*@ assert ¬\valid(t2.p) ∧ ¬\valid(t2.q); */
{
int __gen_e_acsl_initialized_3;
int __gen_e_acsl_and_4;
int __gen_e_acsl_and_6;
__gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& t2.p),
sizeof(char *));
if (__gen_e_acsl_initialized_3) {
int __gen_e_acsl_valid_3;
__gen_e_acsl_valid_3 = __e_acsl_valid((void *)t2.p,sizeof(char),
(void *)t2.p,(void *)(& t2.p));
__gen_e_acsl_and_4 = __gen_e_acsl_valid_3;
}
else __gen_e_acsl_and_4 = 0;
if (! __gen_e_acsl_and_4) {
int __gen_e_acsl_initialized_4;
int __gen_e_acsl_and_5;
__gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& t2.q),
sizeof(char *));
if (__gen_e_acsl_initialized_4) {
int __gen_e_acsl_valid_4;
__gen_e_acsl_valid_4 = __e_acsl_valid((void *)t2.q,sizeof(char),
(void *)t2.q,(void *)(& t2.q));
__gen_e_acsl_and_5 = __gen_e_acsl_valid_4;
}
else __gen_e_acsl_and_5 = 0;
__gen_e_acsl_and_6 = ! __gen_e_acsl_and_5;
}
else __gen_e_acsl_and_6 = 0;
__e_acsl_assert(__gen_e_acsl_and_6,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(t2.p) && !\\valid(t2.q)",32);
}
__e_acsl_temporal_memcpy((void *)(& t2),(void *)(& t1),(size_t)16);
__e_acsl_full_init((void *)(& t2));
t2 = t1;
/*@ assert \valid(t2.p) ∧ \valid(t2.q); */
{
int __gen_e_acsl_initialized_5;
int __gen_e_acsl_and_7;
int __gen_e_acsl_and_9;
__gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& t2.p),
sizeof(char *));
if (__gen_e_acsl_initialized_5) {
int __gen_e_acsl_valid_5;
__gen_e_acsl_valid_5 = __e_acsl_valid((void *)t2.p,sizeof(char),
(void *)t2.p,(void *)(& t2.p));
__gen_e_acsl_and_7 = __gen_e_acsl_valid_5;
}
else __gen_e_acsl_and_7 = 0;
if (__gen_e_acsl_and_7) {
int __gen_e_acsl_initialized_6;
int __gen_e_acsl_and_8;
__gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& t2.q),
sizeof(char *));
if (__gen_e_acsl_initialized_6) {
int __gen_e_acsl_valid_6;
__gen_e_acsl_valid_6 = __e_acsl_valid((void *)t2.q,sizeof(char),
(void *)t2.q,(void *)(& t2.q));
__gen_e_acsl_and_8 = __gen_e_acsl_valid_6;
}
else __gen_e_acsl_and_8 = 0;
__gen_e_acsl_and_9 = __gen_e_acsl_and_8;
}
else __gen_e_acsl_and_9 = 0;
__e_acsl_assert(__gen_e_acsl_and_9,(char *)"Assertion",(char *)"main",
(char *)"\\valid(t2.p) && \\valid(t2.q)",35);
}
__e_acsl_temporal_store_nblock((void *)(& t2.p),(void *)0);
__e_acsl_initialize((void *)(& t2.p),sizeof(char *));
t2.p = (char *)0;
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_initialize((void *)(& t2.q),sizeof(char *));
t2.q = (char *)malloc((unsigned long)4);
__e_acsl_temporal_store_nblock((void *)(& t2.q),(void *)*(& t2.q));
/*@ assert ¬\valid(t2.p) ∧ \valid(t2.q); */
{
int __gen_e_acsl_initialized_7;
int __gen_e_acsl_and_10;
int __gen_e_acsl_and_12;
__gen_e_acsl_initialized_7 = __e_acsl_initialized((void *)(& t2.p),
sizeof(char *));
if (__gen_e_acsl_initialized_7) {
int __gen_e_acsl_valid_7;
__gen_e_acsl_valid_7 = __e_acsl_valid((void *)t2.p,sizeof(char),
(void *)t2.p,(void *)(& t2.p));
__gen_e_acsl_and_10 = __gen_e_acsl_valid_7;
}
else __gen_e_acsl_and_10 = 0;
if (! __gen_e_acsl_and_10) {
int __gen_e_acsl_initialized_8;
int __gen_e_acsl_and_11;
__gen_e_acsl_initialized_8 = __e_acsl_initialized((void *)(& t2.q),
sizeof(char *));
if (__gen_e_acsl_initialized_8) {
int __gen_e_acsl_valid_8;
__gen_e_acsl_valid_8 = __e_acsl_valid((void *)t2.q,sizeof(char),
(void *)t2.q,(void *)(& t2.q));
__gen_e_acsl_and_11 = __gen_e_acsl_valid_8;
}
else __gen_e_acsl_and_11 = 0;
__gen_e_acsl_and_12 = __gen_e_acsl_and_11;
}
else __gen_e_acsl_and_12 = 0;
__e_acsl_assert(__gen_e_acsl_and_12,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(t2.p) && \\valid(t2.q)",39);
}
__e_acsl_temporal_memcpy((void *)(& l.t),(void *)(& t2),(size_t)16);
__e_acsl_initialize((void *)(& l.t),sizeof(struct temporal_t));
l.t = t2;
/*@ assert ¬\valid(l.t.p) ∧ \valid(l.t.q); */
{
int __gen_e_acsl_initialized_9;
int __gen_e_acsl_and_13;
int __gen_e_acsl_and_15;
__gen_e_acsl_initialized_9 = __e_acsl_initialized((void *)(& l.t.p),
sizeof(char *));
if (__gen_e_acsl_initialized_9) {
int __gen_e_acsl_valid_9;
__gen_e_acsl_valid_9 = __e_acsl_valid((void *)l.t.p,sizeof(char),
(void *)l.t.p,(void *)(& l.t.p));
__gen_e_acsl_and_13 = __gen_e_acsl_valid_9;
}
else __gen_e_acsl_and_13 = 0;
if (! __gen_e_acsl_and_13) {
int __gen_e_acsl_initialized_10;
int __gen_e_acsl_and_14;
__gen_e_acsl_initialized_10 = __e_acsl_initialized((void *)(& l.t.q),
sizeof(char *));
if (__gen_e_acsl_initialized_10) {
int __gen_e_acsl_valid_10;
__gen_e_acsl_valid_10 = __e_acsl_valid((void *)l.t.q,sizeof(char),
(void *)l.t.q,
(void *)(& l.t.q));
__gen_e_acsl_and_14 = __gen_e_acsl_valid_10;
}
else __gen_e_acsl_and_14 = 0;
__gen_e_acsl_and_15 = __gen_e_acsl_and_14;
}
else __gen_e_acsl_and_15 = 0;
__e_acsl_assert(__gen_e_acsl_and_15,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(l.t.p) && \\valid(l.t.q)",42);
}
__e_acsl_temporal_store_nblock((void *)(& lp),(void *)(& l));
__e_acsl_full_init((void *)(& lp));
lp = & l;
/*@ assert ¬\valid(lp->t.p); */
{
int __gen_e_acsl_initialized_11;
int __gen_e_acsl_and_16;
__gen_e_acsl_initialized_11 = __e_acsl_initialized((void *)(& lp->t.p),
sizeof(char *));
if (__gen_e_acsl_initialized_11) {
int __gen_e_acsl_valid_read;
int __gen_e_acsl_valid_11;
__gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(& lp->t.p),
sizeof(char *),
(void *)(& lp->t.p),
(void *)0);
__e_acsl_assert(__gen_e_acsl_valid_read,(char *)"RTE",(char *)"main",
(char *)"mem_access: \\valid_read(&lp->t.p)",45);
__gen_e_acsl_valid_11 = __e_acsl_valid((void *)lp->t.p,sizeof(char),
(void *)lp->t.p,
(void *)(& lp->t.p));
__gen_e_acsl_and_16 = __gen_e_acsl_valid_11;
}
else __gen_e_acsl_and_16 = 0;
__e_acsl_assert(! __gen_e_acsl_and_16,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(lp->t.p)",45);
}
__e_acsl_temporal_memcpy((void *)(tarr),(void *)(& t2),(size_t)16);
__e_acsl_initialize((void *)(tarr),sizeof(temporal));
tarr[0] = t2;
/*@ assert ¬\valid(tarr[0].p) ∧ \valid(tarr[0].q); */
{
int __gen_e_acsl_initialized_12;
int __gen_e_acsl_and_17;
int __gen_e_acsl_and_19;
__gen_e_acsl_initialized_12 = __e_acsl_initialized((void *)(& tarr[0].p),
sizeof(char *));
if (__gen_e_acsl_initialized_12) {
int __gen_e_acsl_valid_12;
__gen_e_acsl_valid_12 = __e_acsl_valid((void *)tarr[0].p,sizeof(char),
(void *)tarr[0].p,
(void *)(& tarr[0].p));
__gen_e_acsl_and_17 = __gen_e_acsl_valid_12;
}
else __gen_e_acsl_and_17 = 0;
if (! __gen_e_acsl_and_17) {
int __gen_e_acsl_initialized_13;
int __gen_e_acsl_and_18;
__gen_e_acsl_initialized_13 = __e_acsl_initialized((void *)(& tarr[0].q),
sizeof(char *));
if (__gen_e_acsl_initialized_13) {
int __gen_e_acsl_valid_13;
__gen_e_acsl_valid_13 = __e_acsl_valid((void *)tarr[0].q,
sizeof(char),
(void *)tarr[0].q,
(void *)(& tarr[0].q));
__gen_e_acsl_and_18 = __gen_e_acsl_valid_13;
}
else __gen_e_acsl_and_18 = 0;
__gen_e_acsl_and_19 = __gen_e_acsl_and_18;
}
else __gen_e_acsl_and_19 = 0;
__e_acsl_assert(__gen_e_acsl_and_19,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(tarr[0].p) && \\valid(tarr[0].q)",48);
}
__e_acsl_temporal_memcpy((void *)(larr),(void *)(& l),(size_t)32);
__e_acsl_initialize((void *)(larr),sizeof(larger));
larr[0] = l;
/*@ assert ¬\valid(larr[0].t.p) ∧ \valid(larr[0].t.q); */
{
int __gen_e_acsl_initialized_14;
int __gen_e_acsl_and_20;
int __gen_e_acsl_and_22;
__gen_e_acsl_initialized_14 = __e_acsl_initialized((void *)(& larr[0].t.p),
sizeof(char *));
if (__gen_e_acsl_initialized_14) {
int __gen_e_acsl_valid_14;
__gen_e_acsl_valid_14 = __e_acsl_valid((void *)larr[0].t.p,
sizeof(char),
(void *)larr[0].t.p,
(void *)(& larr[0].t.p));
__gen_e_acsl_and_20 = __gen_e_acsl_valid_14;
}
else __gen_e_acsl_and_20 = 0;
if (! __gen_e_acsl_and_20) {
int __gen_e_acsl_initialized_15;
int __gen_e_acsl_and_21;
__gen_e_acsl_initialized_15 = __e_acsl_initialized((void *)(& larr[0].t.q),
sizeof(char *));
if (__gen_e_acsl_initialized_15) {
int __gen_e_acsl_valid_15;
__gen_e_acsl_valid_15 = __e_acsl_valid((void *)larr[0].t.q,
sizeof(char),
(void *)larr[0].t.q,
(void *)(& larr[0].t.q));
__gen_e_acsl_and_21 = __gen_e_acsl_valid_15;
}
else __gen_e_acsl_and_21 = 0;
__gen_e_acsl_and_22 = __gen_e_acsl_and_21;
}
else __gen_e_acsl_and_22 = 0;
__e_acsl_assert(__gen_e_acsl_and_22,(char *)"Assertion",(char *)"main",
(char *)"!\\valid(larr[0].t.p) && \\valid(larr[0].t.q)",
51);
}
__retres = 0;
__e_acsl_delete_block((void *)(larr));
__e_acsl_delete_block((void *)(& lp));
__e_acsl_delete_block((void *)(& l));
__e_acsl_delete_block((void *)(tarr));
__e_acsl_delete_block((void *)(& t2));
__e_acsl_delete_block((void *)(& t1));
__e_acsl_delete_block((void *)(& a));
__e_acsl_memory_clean();
return __retres;
}
/* compiler builtin:
void *__builtin_alloca(unsigned long); */
void test_specifier_application(char const *allowed, char const *fmt,
int only_negative, char *at)
{
size_t tmp;
unsigned long __lengthof_format;
__e_acsl_store_block((void *)(& __lengthof_format),(size_t)8);
__e_acsl_store_block((void *)(& tmp),(size_t)8);
__e_acsl_store_block((void *)(& at),(size_t)8);
__e_acsl_store_block((void *)(& only_negative),(size_t)4);
__e_acsl_store_block((void *)(& fmt),(size_t)8);
__e_acsl_store_block((void *)(& allowed),(size_t)8);
__e_acsl_full_init((void *)(& tmp));
tmp = __gen_e_acsl_strlen(fmt);
int len = (int)tmp;
__e_acsl_store_block((void *)(& len),(size_t)4);
__e_acsl_full_init((void *)(& len));
/*@ assert
alloca_bounds: 0 < sizeof(char) * (len + 1) ≤ 18446744073709551615;
*/
{
int __gen_e_acsl_and;
if (0L < 1L * (len + 1L)) {
__e_acsl_mpz_t __gen_e_acsl_;
__e_acsl_mpz_t __gen_e_acsl__2;
int __gen_e_acsl_le;
__gmpz_init_set_si(__gen_e_acsl_,1L * (len + 1L));
__gmpz_init_set_ui(__gen_e_acsl__2,18446744073709551615UL);
__gen_e_acsl_le = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__2));
__gen_e_acsl_and = __gen_e_acsl_le <= 0;
__gmpz_clear(__gen_e_acsl_);
__gmpz_clear(__gen_e_acsl__2);
}
else __gen_e_acsl_and = 0;
__e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",
(char *)"test_specifier_application",
(char *)"alloca_bounds: 0 < sizeof(char) * (len + 1) <= 18446744073709551615",
82);
}
__e_acsl_full_init((void *)(& __lengthof_format));
__lengthof_format = (unsigned long)(len + 1);
char *format = __builtin_alloca(sizeof(char) * __lengthof_format);
__e_acsl_store_block((void *)format,sizeof(char) * __lengthof_format);
__e_acsl_store_block((void *)(& format),(size_t)8);
__e_acsl_full_init((void *)(& format));
__gen_e_acsl_strcpy(format,fmt);
{
int i_0 = 0;
__e_acsl_store_block((void *)(& i_0),(size_t)4);
__e_acsl_full_init((void *)(& i_0));
while (1) {
size_t tmp_3;
__e_acsl_store_block((void *)(& tmp_3),(size_t)8);
__e_acsl_full_init((void *)(& tmp_3));
tmp_3 = __gen_e_acsl_strlen(valid_specifiers);
;
if (! ((size_t)i_0 < tmp_3)) {
__e_acsl_delete_block((void *)(& tmp_3));
break;
}
{
char *tmp_2;
__e_acsl_store_block((void *)(& tmp_2),(size_t)8);
int c = (int)*(valid_specifiers + i_0);
__e_acsl_store_block((void *)(& c),(size_t)4);
__e_acsl_full_init((void *)(& c));
__e_acsl_initialize((void *)(format + (len - 1)),sizeof(char));
*(format + (len - 1)) = (char)c;
__e_acsl_full_init((void *)(& tmp_2));
tmp_2 = __gen_e_acsl_strchr(allowed,c);
if (tmp_2) {
if (! only_negative) {
{
pid_t pid = fork();
__e_acsl_store_block((void *)(& pid),(size_t)4);
__e_acsl_full_init((void *)(& pid));
if (! pid) {
apply_specifier(format,c);
__gen_e_acsl_exit(0);
}
else {
int process_status;
__e_acsl_store_block((void *)(& process_status),(size_t)4);
waitpid(pid,& process_status,0);
signal_eval(process_status,0,(char const *)at);
__e_acsl_delete_block((void *)(& process_status));
}
__e_acsl_delete_block((void *)(& pid));
}
}
}
else {
{
pid_t pid_0 = fork();
__e_acsl_store_block((void *)(& pid_0),(size_t)4);
__e_acsl_full_init((void *)(& pid_0));
if (! pid_0) {
apply_specifier(format,c);
__gen_e_acsl_exit(0);
}
else {
int process_status_0;
__e_acsl_store_block((void *)(& process_status_0),(size_t)4);
waitpid(pid_0,& process_status_0,0);
signal_eval(process_status_0,1,(char const *)at);
__e_acsl_delete_block((void *)(& process_status_0));
}
__e_acsl_delete_block((void *)(& pid_0));
}
}
__e_acsl_delete_block((void *)(& tmp_2));
__e_acsl_delete_block((void *)(& c));
}
__e_acsl_full_init((void *)(& i_0));
i_0 ++;
__e_acsl_delete_block((void *)(& tmp_3));
}
__e_acsl_delete_block((void *)(& i_0));
}
__e_acsl_delete_block((void *)format);
__e_acsl_delete_block((void *)(& at));
__e_acsl_delete_block((void *)(& only_negative));
__e_acsl_delete_block((void *)(& fmt));
__e_acsl_delete_block((void *)(& allowed));
__e_acsl_delete_block((void *)(& __lengthof_format));
__e_acsl_delete_block((void *)(& format));
__e_acsl_delete_block((void *)(& tmp));
__e_acsl_delete_block((void *)(& len));
return;
}
