int irept::compare(const irept &i) const
{
int r;
r=id().compare(i.id());
if(r!=0) return r;
const subt::size_type size=get_sub().size(),
i_size=i.get_sub().size();
if(size<i_size) return -1;
if(size>i_size) return 1;
{
irept::subt::const_iterator it1, it2;
for(it1=get_sub().begin(),
it2=i.get_sub().begin();
it1!=get_sub().end() && it2!=i.get_sub().end();
it1++,
it2++)
{
r=it1->compare(*it2);
if(r!=0) return r;
}
assert(it1==get_sub().end() && it2==i.get_sub().end());
}
const named_subt::size_type n_size=get_named_sub().size(),
i_n_size=i.get_named_sub().size();
if(n_size<i_n_size) return -1;
if(n_size>i_n_size) return 1;
{
irept::named_subt::const_iterator it1, it2;
for(it1=get_named_sub().begin(),
it2=i.get_named_sub().begin();
it1!=get_named_sub().end() && it2!=i.get_named_sub().end();
it1++,
it2++)
{
r=it1->first.compare(it2->first);
if(r!=0) return r;
r=it1->second.compare(it2->second);
if(r!=0) return r;
}
assert(it1==get_named_sub().end() &&
it2==i.get_named_sub().end());
}
// equal
return 0;
}
bool operator==(const irept &i1, const irept &i2)
{
#ifdef SHARING
if(i1.data==i2.data) return true;
#endif
if(i1.id()!=i2.id()) return false;
if(i1.get_sub()!=i2.get_sub()) return false; // recursive call
if(i1.get_named_sub()!=i2.get_named_sub()) return false; // recursive call
// comments are NOT checked
return true;
}
bool full_eq(const irept &i1, const irept &i2)
{
#ifdef SHARING
if(i1.data==i2.data) return true;
#endif
if(i1.id()!=i2.id()) return false;
const irept::subt &i1_sub=i1.get_sub();
const irept::subt &i2_sub=i2.get_sub();
const irept::named_subt &i1_named_sub=i1.get_named_sub();
const irept::named_subt &i2_named_sub=i2.get_named_sub();
const irept::named_subt &i1_comments=i1.get_comments();
const irept::named_subt &i2_comments=i2.get_comments();
if(i1_sub.size() !=i2_sub.size()) return false;
if(i1_named_sub.size()!=i2_named_sub.size()) return false;
if(i1_comments.size() !=i2_comments.size()) return false;
for(unsigned i=0; i<i1_sub.size(); i++)
if(!full_eq(i1_sub[i], i2_sub[i]))
return false;
{
irept::named_subt::const_iterator i1_it=i1_named_sub.begin();
irept::named_subt::const_iterator i2_it=i2_named_sub.begin();
for(; i1_it!=i1_named_sub.end(); i1_it++, i2_it++)
if(i1_it->first!=i2_it->first ||
!full_eq(i1_it->second, i2_it->second))
return false;
}
{
irept::named_subt::const_iterator i1_it=i1_comments.begin();
irept::named_subt::const_iterator i2_it=i2_comments.begin();
for(; i1_it!=i1_comments.end(); i1_it++, i2_it++)
if(i1_it->first!=i2_it->first ||
!full_eq(i1_it->second, i2_it->second))
return false;
}
return true;
}
/// To convert to JSON from an irep structure by recurssively generating JSON
/// for the different sub trees.
/// \param irep: The irep structure to turn into json
/// \param json: The json object to be filled up.
void json_irept::convert_from_irep(const irept &irep, jsont &json) const
{
json_objectt &irep_object=json.make_object();
if(irep.id()!=ID_nil)
irep_object["id"]=json_stringt(irep.id_string());
convert_sub_tree("sub", irep.get_sub(), irep_object);
convert_named_sub_tree("namedSub", irep.get_named_sub(), irep_object);
if(include_comments)
{
convert_named_sub_tree("comment", irep.get_comments(), irep_object);
}
}
bool operator==(const irept &i1, const irept &i2)
{
#ifdef IREP_HASH_STATS
++irep_cmp_cnt;
#endif
#ifdef SHARING
if(i1.data==i2.data) return true;
#endif
if(i1.id()!=i2.id() ||
i1.get_sub()!=i2.get_sub() || // recursive call
i1.get_named_sub()!=i2.get_named_sub()) // recursive call
{
#ifdef IREP_HASH_STATS
++irep_cmp_ne_cnt;
#endif
return false;
}
// comments are NOT checked
return true;
}
void jsa_serialisert::operator()(jsa_genetic_solutiont &entity,
const irept &sdu) const
{
entity.fitness=jsa_genetic_solutiont::fitnesst(sdu.get_long_long(FITNESS));
const irept::named_subt &named_sub=sdu.get_named_sub();
typedef irept::named_subt::const_iterator const_iterator;
const const_iterator invariant=named_sub.find(INVARIANT);
assert(named_sub.end() != invariant);
for (const irept &instruction : invariant->second.get_sub())
{
jsa_genetic_solutiont::invariantt::value_type instr;
instr.opcode=__CPROVER_jsa_opcodet(instruction.get_long_long(OPCODE));
entity.invariant.push_back(instr);
}
const const_iterator predicates=named_sub.find(PREDICATES);
assert(named_sub.end() != predicates);
for (const irept &predicate : predicates->second.get_sub())
{
jsa_genetic_solutiont::predicatet pred;
for (const irept &instruction : predicate.get_sub())
{
jsa_genetic_solutiont::predicatet::value_type instr;
instr.opcode=__CPROVER_jsa_opcodet(instruction.get_long_long(OPCODE));
instr.op0=__CPROVER_jsa_opt(instruction.get_long_long(OP0));
instr.op1=__CPROVER_jsa_opt(instruction.get_long_long(OP1));
instr.result_op=__CPROVER_jsa_opt(instruction.get_long_long(RESULT_OP));
pred.push_back(instr);
}
entity.predicates.push_back(pred);
}
const const_iterator query=named_sub.find(QUERY);
assert(named_sub.end() != query);
for (const irept &instruction : query->second.get_sub())
{
jsa_genetic_solutiont::queryt::value_type instr;
instr.opcode=__CPROVER_jsa_opcodet(instruction.get_long_long(OPCODE));
instr.op0=__CPROVER_jsa_opt(instruction.get_long_long(OP0));
instr.op1=__CPROVER_jsa_opt(instruction.get_long_long(OP1));
entity.query.push_back(instr);
}
}
void irep_hash_container_baset::pack(
const irept &irep,
packedt &packed)
{
const irept::subt &sub=irep.get_sub();
const irept::named_subt &named_sub=irep.get_named_sub();
const irept::named_subt &comments=irep.get_comments();
packed.reserve(
1+1+sub.size()+named_sub.size()*2+
(full?comments.size()*2:0));
packed.push_back(irep_id_hash()(irep.id()));
packed.push_back(sub.size());
forall_irep(it, sub)
packed.push_back(number(*it));
packed.push_back(named_sub.size());
forall_named_irep(it, named_sub)
{
packed.push_back(irep_id_hash()(it->first)); // id
packed.push_back(number(it->second)); // sub-irep
}