int
boolector_is_array (Btor * btor, BtorNode * exp)
{
BTOR_ABORT_ARG_NULL_BOOLECTOR (btor);
BTOR_ABORT_ARG_NULL_BOOLECTOR (exp);
BTOR_ABORT_REFS_NOT_POS_BOOLECTOR (exp);
exp = btor_pointer_chase_simplified_exp (btor, exp);
return btor_is_array_exp (btor, exp);
}
static BtorNode *
parse_exp (BtorBTORParser * parser, int expected_len, int can_be_array)
{
int lit, idx, len_res;
BtorNode *res;
lit = 0;
if (parse_non_zero_int (parser, &lit))
return 0;
idx = abs (lit);
assert (idx);
if (idx >= BTOR_COUNT_STACK (parser->exps) ||
!(res = parser->exps.start[idx]))
{
(void) btor_perr_btor (parser, "literal '%d' undefined", lit);
return 0;
}
if (!can_be_array && btor_is_array_exp (parser->btor, res))
{
(void)
btor_perr_btor (parser,
"literal '%d' refers to an unexpected array expression",
lit);
return 0;
}
if (expected_len)
{
len_res = btor_get_exp_len (parser->btor, res);
if (expected_len != len_res)
{
(void)
btor_perr_btor (parser,
"literal '%d' has length '%d' but expected '%d'",
lit, len_res, expected_len);
return 0;
}
}
if (lit < 0)
res = btor_not_exp (parser->btor, res);
else
res = btor_copy_exp (parser->btor, res);
return res;
}
static BtorNode *
parse_next (BtorBTORParser * parser, int len)
{
int idx;
BtorNode * current, * next;
Info info;
if (parse_space (parser))
return 0;
if (parse_positive_int (parser, &idx))
return 0;
if (idx >= BTOR_COUNT_STACK (parser->exps) ||
!(current = parser->exps.start[idx]))
{
(void) btor_perr_btor (parser, "invalid next index %d", idx);
return 0;
}
info = parser->info.start[idx];
if (!info.var)
{
(void) btor_perr_btor (parser, "next index %d is not a variable", idx);
return 0;
}
if (info.next)
{
(void) btor_perr_btor (parser, "next index %d already used", idx);
return 0;
}
if (parse_space (parser))
return 0;
assert (!btor_is_array_exp (parser->btor, current));
if (!(next = parse_exp (parser, len, 0)))
return 0;
BTOR_PUSH_STACK (parser->mem, parser->regs, current);
BTOR_PUSH_STACK (parser->mem, parser->nexts, next);
parser->info.start[idx].next = 1;
return next;
}
static BtorNode *
parse_array_exp (BtorBTORParser * parser, int len)
{
BtorNode * res;
res = parse_exp (parser, len, 1);
if (!res)
return 0;
if (btor_is_array_exp (parser->btor, res))
return res;
(void) btor_perr_btor (parser, "expected array expression");
btor_release_exp (parser->btor, res);
return 0;
}
static BtorNode *
parse_anext (BtorBTORParser * parser, int len)
{
int idx, current_idx_len, idx_len;
BtorNode * current, * next;
Info info;
if (parse_space (parser))
return 0;
if (parse_positive_int (parser, &idx_len))
return 0;
if (parse_space (parser))
return 0;
if (parse_positive_int (parser, &idx))
return 0;
if (idx >= BTOR_COUNT_STACK (parser->exps) ||
!(current = parser->exps.start[idx]))
{
(void) btor_perr_btor (parser, "invalid next index %d", idx);
return 0;
}
info = parser->info.start[idx];
if (!info.array)
{
(void) btor_perr_btor (parser, "next index %d is not an array", idx);
return 0;
}
if (info.next)
{
(void) btor_perr_btor (parser, "next index %d already used", idx);
return 0;
}
if (parse_space (parser))
return 0;
assert (btor_is_array_exp (parser->btor, current));
if (!(next = parse_array_exp (parser, len)))
return 0;
current_idx_len = btor_get_index_exp_len (parser->btor, current);
if (idx_len != current_idx_len)
{
btor_release_exp (parser->btor, next);
(void) btor_perr_btor (parser,
"arrays with different index width %d and %d",
current_idx_len, idx_len);
return 0;
}
BTOR_PUSH_STACK (parser->mem, parser->regs, current);
BTOR_PUSH_STACK (parser->mem, parser->nexts, next);
parser->info.start[idx].next = 1;
return next;
}
static BtorNode *
parse_compare_and_overflow (BtorBTORParser * parser,
int len, Binary f, int can_be_array)
{
BtorNode *l, *r, *res;
int llen, rlen;
if (len != 1)
{
(void) btor_perr_btor (parser,
"comparison or overflow operator returns %d bits",
len);
return 0;
}
if (parse_space (parser))
return 0;
if (!(l = parse_exp (parser, 0, can_be_array)))
return 0;
if (parse_space (parser))
{
RELEASE_L_AND_RETURN_ERROR:
btor_release_exp (parser->btor, l);
return 0;
}
if (!(r = parse_exp (parser, 0, can_be_array)))
goto RELEASE_L_AND_RETURN_ERROR;
llen = btor_get_exp_len (parser->btor, l);
rlen = btor_get_exp_len (parser->btor, r);
if (llen != rlen)
{
(void)
btor_perr_btor (parser,
"operands have different bit width %d and %d",
llen, rlen);
RELEASE_L_AND_R_AND_RETURN_ZERO:
btor_release_exp (parser->btor, r);
btor_release_exp (parser->btor, l);
return 0;
}
if (can_be_array)
{
if (btor_is_array_exp (parser->btor, l) &&
!btor_is_array_exp (parser->btor, r))
{
(void) btor_perr_btor (parser,
"first operand is array and second not");
goto RELEASE_L_AND_R_AND_RETURN_ZERO;
}
if (!btor_is_array_exp (parser->btor, l) &&
btor_is_array_exp (parser->btor, r))
{
(void) btor_perr_btor (parser,
"second operand is array and first not");
goto RELEASE_L_AND_R_AND_RETURN_ZERO;
}
if (btor_is_array_exp (parser->btor, l) &&
btor_is_array_exp (parser->btor, r))
{
llen = btor_get_index_exp_len (parser->btor, l);
rlen = btor_get_index_exp_len (parser->btor, r);
if (llen != rlen)
{
(void) btor_perr_btor (
parser,
"array operands have different index width %d and %d",
llen, rlen);
goto RELEASE_L_AND_R_AND_RETURN_ZERO;
}
}
}
res = f (parser->btor, l, r);
btor_release_exp (parser->btor, r);
btor_release_exp (parser->btor, l);
assert (btor_get_exp_len (parser->btor, res) == 1);
return res;
}
int
main (int argc, char ** argv)
{
int i, j, verbosity, close_input, close_output, binary, merge;
const char * input_name, * output_name;
FILE * input_file, * output_file, * file;
BtorAIG * aig, * tmp, * merged, ** p;
BtorPtrHashTable * back_annotation;
const char * parse_error;
BtorPtrHashBucket *b;
BtorParseResult model;
BtorAIGVecMgr * avmgr;
BtorAIGPtrStack regs;
BtorAIGPtrStack nexts;
BtorAIGPtrStack aigs;
BtorParser * parser;
BtorAIGMgr * amgr;
BtorMemMgr * mem;
BtorAIGVec * av;
Btor * btor;
verbosity = 0;
close_input = 0;
close_output = 0;
binary = 0;
merge = 0;
input_name = "<stdin>";
output_name = "<stdout>";
input_file = stdin;
output_file = stdout;
for (i = 1; i < argc; i++)
{
if (!strcmp (argv[i], "-h"))
{
printf ("usage: synthebor [-h][-v][-m][<input>[<output>]]\n");
exit (0);
}
else if (!strcmp (argv[i], "-v"))
verbosity++;
else if (!strcmp (argv[i], "-m"))
merge = 1;
else if (argv[i][0] == '-')
die (1, "invalid command line option '%s'", argv[i]);
else if (close_output)
die (1, "too many files");
else if (close_input)
{
if (!strcmp (argv[i], input_name))
die (1, "input and output are the same");
if (!(file = fopen (argv[i], "w")))
die (1, "can not write '%s'", argv[i]);
output_file = file;
output_name = argv[i];
close_output = 1;
}
else if (!(file = fopen (argv[i], "r")))
die (1, "can not read '%s'", argv[i]);
else
{
input_file = file;
input_name = argv[i];
close_input = 1;
}
}
btor = btor_new_btor ();
btor_set_verbosity_btor (btor, verbosity);
btor_set_rewrite_level_btor (btor, 1);
parser = btor_btor_parser_api ()->init (btor, verbosity);
parse_error = btor_btor_parser_api()->parse (parser,
input_file,
input_name,
&model);
if (parse_error)
die (0, parse_error);
if (!model.noutputs)
die (1, "no roots in '%s'", input_name);
if (model.nregs && merge)
die (1, "can not merge registers");
mem = btor->mm;
avmgr = btor->avmgr;
amgr = btor_get_aig_mgr_aigvec_mgr (avmgr);
back_annotation = btor_new_ptr_hash_table (mem, 0, 0);
BTOR_INIT_STACK (regs);
BTOR_INIT_STACK (nexts);
for (i = 0; i < model.nregs; i++)
{
if (btor_is_array_exp (btor, model.regs[i]))
die (1, "can not synthesize memories (yet)");
av = btor_exp_to_aigvec (btor, model.regs[i], back_annotation);
for (j = 0; j < av->len; j++)
{
aig = btor_copy_aig (amgr, av->aigs[j]);
BTOR_PUSH_STACK (mem, regs, aig);
}
btor_release_delete_aigvec (avmgr, av);
av = btor_exp_to_aigvec (btor, model.nexts[i], back_annotation);
for (j = 0; j < av->len; j++)
{
aig = btor_copy_aig (amgr, av->aigs[j]);
BTOR_PUSH_STACK (mem, nexts, aig);
}
btor_release_delete_aigvec (avmgr, av);
}
BTOR_INIT_STACK (aigs);
merged = BTOR_AIG_TRUE;
for (i = 0; i < model.noutputs; i++)
{
av = btor_exp_to_aigvec (btor, model.outputs[i], back_annotation);
for (j = 0; j < av->len; j++)
{
aig = av->aigs[j];
if (merge)
{
tmp = btor_and_aig (amgr, merged, aig);
btor_release_aig (amgr, merged);
merged = tmp;
}
else
{
aig = btor_copy_aig (amgr, aig);
BTOR_PUSH_STACK (mem, aigs, aig);
}
}
btor_release_delete_aigvec (avmgr, av);
}
if (merge)
BTOR_PUSH_STACK (mem, aigs, merged);
#ifdef BTOR_HAVE_ISATTY
if (close_output || !isatty (1))
binary = 1;
#endif
assert (BTOR_COUNT_STACK (regs) == BTOR_COUNT_STACK (nexts));
btor_dump_aiger (amgr,
binary, output_file,
BTOR_COUNT_STACK (aigs), aigs.start,
BTOR_COUNT_STACK (regs), regs.start, nexts.start,
back_annotation);
for (p = aigs.start; p < aigs.top; p++)
btor_release_aig (amgr, *p);
BTOR_RELEASE_STACK (mem, aigs);
for (p = regs.start; p < regs.top; p++)
btor_release_aig (amgr, *p);
BTOR_RELEASE_STACK (mem, regs);
for (p = nexts.start; p < nexts.top; p++)
btor_release_aig (amgr, *p);
BTOR_RELEASE_STACK (mem, nexts);
for (b = back_annotation->first; b; b = b->next)
btor_freestr (mem, b->data.asStr);
btor_delete_ptr_hash_table (back_annotation);
btor_btor_parser_api()->reset (parser);
btor_delete_btor (btor);
if (close_input)
fclose (input_file);
if (close_output)
fclose (output_file);
return 0;
}
