// and_expr
// and_expr || or_expr_list
//
int64_t or_expr()
{
int64_t val;
val = and_expr();
while(token==tk_lor) {
NextToken();
val = val || and_expr();
}
return val;
}
static struct ast_node*
rest_or(struct ast_node *node)
{
struct ast_node *ret_node;
struct ast_node *left;
struct ast_node *right;
ret_node = node;
while (TRUE) {
switch(current_token) {
case TOKEN_OR :
consume_token();
left = ret_node;
right = and_expr();
if (right == NULL) {
error_msg("error: expression expected after ||");
right = (struct ast_node *)ast_node_stub();
sync_stream();
}
ret_node = (struct ast_node *)ast_node_logic_op(OPCODE_OR, left, right);
continue;
default:
goto exit_or;
}
}
exit_or:
return ret_node;
}
reg_expr()
#endif
{
zzRULE;
zzBLOCK(zztasp1);
zzMake0;
{
and_expr();
zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
{
zzBLOCK(zztasp2);
zzMake0;
{
while ( (LA(1)==OR) ) {
zzmatch(OR); zzCONSUME;
and_expr();
{nfa_node *t1, *t2;
t1 = new_nfa_node(); t2 = new_nfa_node();
(t1)->trans[0]=zzaRet.l;
(t1)->trans[1]=zzaArg(zztasp2,2 ).l;
/* MR23 */ if (zzaRet.r != NULL) (zzaRet.r)->trans[1]=t2;
if (zzaArg(zztasp2,2 ).r) {
(zzaArg(zztasp2,2 ).r)->trans[1]=t2; /* MR20 */
}
zzaRet.l=t1; zzaRet.r=t2;
}
zzLOOP(zztasp2);
}
zzEXIT(zztasp2);
}
}
zzEXIT(zztasp1);
return;
fail:
zzEXIT(zztasp1);
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd2, 0x4);
}
}
static struct ast_node*
or_expr(void)
{
struct ast_node *node;
struct ast_node *rest_node;
node = and_expr();
if (node == NULL)
return NULL;
rest_node = rest_or(node);
return rest_node;
}
void bv_cbmct::convert_waitfor(const exprt &expr, bvt &bv)
{
if(expr.operands().size()!=4)
throw "waitfor expected to have four operands";
exprt new_cycle;
const exprt &old_cycle=expr.op0();
const exprt &cycle_var=expr.op1();
const exprt &bound=expr.op2();
const exprt &predicate=expr.op3();
make_free_bv_expr(expr.type(), new_cycle);
mp_integer bound_value;
if(to_integer(bound, bound_value))
throw "waitfor bound must be a constant";
{
// constraint: new_cycle>=old_cycle
exprt rel_expr(ID_ge, bool_typet());
rel_expr.copy_to_operands(new_cycle, old_cycle);
set_to_true(rel_expr);
}
{
// constraint: new_cycle<=bound+1
exprt one=from_integer(1, bound.type());
exprt bound_plus1(ID_plus, bound.type());
bound_plus1.reserve_operands(2);
bound_plus1.copy_to_operands(bound);
bound_plus1.move_to_operands(one);
exprt rel_expr(ID_le, bool_typet());
rel_expr.copy_to_operands(new_cycle, bound_plus1);
set_to_true(rel_expr);
}
for(mp_integer i=0; i<=bound_value; i=i+1)
{
// replace cycle_var by old_cycle+i;
exprt old_cycle_plus_i(ID_plus, old_cycle.type());
old_cycle_plus_i.operands().resize(2);
old_cycle_plus_i.op0()=old_cycle;
old_cycle_plus_i.op1()=from_integer(i, old_cycle.type());
exprt tmp_predicate=predicate;
replace_expr(cycle_var, old_cycle_plus_i, tmp_predicate);
// CONSTRAINT:
// if((cycle)<=bound) {
// if((cycle)<new_cycle)
// assume(!property);
// else if((cycle)==new_cycle)
// assume(property);
{
exprt cycle_le_bound(ID_le, bool_typet());
cycle_le_bound.operands().resize(2);
cycle_le_bound.op0()=old_cycle_plus_i;
cycle_le_bound.op1()=bound;
exprt cycle_lt_new_cycle(ID_lt, bool_typet());
cycle_lt_new_cycle.operands().resize(2);
cycle_lt_new_cycle.op0()=old_cycle_plus_i;
cycle_lt_new_cycle.op1()=new_cycle;
exprt and_expr(ID_and, bool_typet());
and_expr.operands().resize(2);
and_expr.op0().swap(cycle_le_bound);
and_expr.op1().swap(cycle_lt_new_cycle);
exprt top_impl(ID_implies, bool_typet());
top_impl.reserve_operands(2);
top_impl.move_to_operands(and_expr);
top_impl.copy_to_operands(tmp_predicate);
top_impl.op1().make_not();
set_to_true(top_impl);
}
{
exprt cycle_le_bound(ID_le, bool_typet());
cycle_le_bound.operands().resize(2);
cycle_le_bound.op0()=old_cycle_plus_i;
cycle_le_bound.op1()=bound;
exprt cycle_eq_new_cycle(ID_equal, bool_typet());
cycle_eq_new_cycle.operands().resize(2);
cycle_eq_new_cycle.op0()=old_cycle_plus_i;
cycle_eq_new_cycle.op1()=new_cycle;
exprt and_expr(ID_and, bool_typet());
and_expr.operands().resize(2);
and_expr.op0().swap(cycle_le_bound);
and_expr.op1().swap(cycle_eq_new_cycle);
exprt top_impl(ID_implies, bool_typet());
top_impl.reserve_operands(2);
top_impl.move_to_operands(and_expr);
top_impl.copy_to_operands(tmp_predicate);
set_to_true(top_impl);
}
}
// result: new_cycle
return convert_bitvector(new_cycle, bv);
}
