Value * map_to_cells ( std::list<Value *> * args, Scope * s ) {
World * world = current_gro_program->get_world();
std::list<Value *>::iterator i = args->begin();
Expr * expression = (*i)->func_body();
while ( expression->get_type() == Expr::CONSTANT ) {
expression = expression->get_val()->func_body();
}
return world->map_to_cells ( expression );
}
BoolOpSeq::BoolOpSeq( Expr expr, bool pos ) {
if ( expr->get_val( val_if_not_or_seq ) )
val_if_not_or_seq ^= not pos;
else
or_seq.push_back()->push_back( Item{ expr, pos } );
}
Expr phi( Expr cond, Expr ok, Expr ko ) {
// known value ?
bool v;
if ( cond.get_val( v ) )
return v ? ok : ko;
// the same value in all the cases ?
if ( ok == ko )
return ok;
// if ok or ko are undefined
// if ( ok.inst->undefined() ) return ko;
// if ( ko.inst->undefined() ) return ok;
// phi( not c, a, b ) -> phi( c, b, a )
if ( cond.inst->inst_id() == Inst::Id_Op_not )
return phi( cond.inst->inp_expr( 0 ), ko, ok );
// phi( c, true, false ) -> c
// phi( c, false, true ) -> not c
if ( ok.size_in_bits() == 1 and ko.size_in_bits() == 1 ) {
bool va, vb;
if ( ok.get_val( va ) and ko.get_val( vb ) ) {
if ( va and not vb )
return cond;
if ( vb and not va )
return op_not( bt_Bool, cond );
}
}
// phi( c, b, c )
if ( cond == ko )
return phi( cond, ok, cst( false ) );
// phi( c, c, b )
if ( cond == ok )
return phi( cond, cst( true ), ko );
// if ok is a phi node tree which contain cond in the conditions
if ( Expr nok = phi_with_cond( cond, 1, ok ) )
return phi( cond, nok, ko );
// if ko is a phi node tree which contain cond in the conditions
if ( Expr nko = phi_with_cond( cond, 0, ko ) )
return phi( cond, ok, nko );
// phi( cond, a, phi( cond, ) )
// cond = bool( ... )
//if ( cond.inst->inst_id() == Inst::Id_Conv and cond.inst->out_bt( 0 ) == bt_Bool )
// cond = cond.inst->inp_expr( 0 );
// else, create a new inst
Phi *res = new Phi;
res->inp_repl( 0, cond );
res->inp_repl( 1, ok );
res->inp_repl( 2, ko );
return Expr( Inst::factorized( res ), 0 );
}