StateMachinePtr construct_asm(BindingsPtr bindings, NodePtr root,
const AbstractStateMachineTable& asmt) {
assert(root && root->get_op() == Op::abstract_state_machine);
assert(root->size() == 4 || root->size() == 5);
int argi = 0;
std::string name = root->get_operand(argi++)->get_token().get_text();
std::string base_sm;
if (root->size() == 5) {
base_sm = root->get_operand(argi++)->get_token().get_text();
}
NodePtr vars = root->get_operand(argi++);
NodePtr funcs = root->get_operand(argi++);
NodePtr rules = root->get_operand(argi++);
StateMachinePtr sm = std::make_shared<StateMachine>(bindings, name);
if (base_sm != "") {
AbstractStateMachineTable::const_iterator it = asmt.find(base_sm);
if (it == asmt.end()) {
throw Exception(root->get_operand(1)->get_location(),
"no such abstract state machine");
}
sm->import_asm(it->second);
}
assert(vars->get_op() == Op::sm_vars);
if (vars->size() > 0) {
add_vars(sm, vars->get_operand(0));
}
assert(funcs->get_op() == Op::sm_functions);
if (funcs->size() > 0) {
add_functions(sm, funcs->get_operand(0));
}
add_rules(sm, bindings, rules);
return sm;
}
static void add_vars(StateMachinePtr sm, NodePtr root) {
if (root->get_op() == Op::sm_var_declarations) {
add_vars(sm, root->get_operand(0));
root = root->get_operand(1);
}
assert(root->get_op() == Op::sm_var_declaration);
StateMachine::VarKind varkind;
if (root->get_operand(0)->get_op() == Op::SHARED) {
varkind = StateMachine::sharedVar;
} else {
varkind = StateMachine::privateVar;
}
std::string varname = root->get_operand(1)->get_token().get_text();
if (root->size() == 2) {
sm->add_var(varkind, varname, root->get_location());
} else {
sm->add_var(varkind, varname, root->get_operand(2), root->get_location());
}
}
void value_set_analysis_fivrt::initialize(
const goto_functionst &goto_functions)
{
baset::initialize(goto_functions);
add_vars(goto_functions);
}
void value_set_analysis_fivrt::initialize(
const goto_programt &goto_program)
{
baset::initialize(goto_program);
add_vars(goto_program);
}
int main(int argc, char **argv)
{
int i, j;
struct kvvec *kvv, *kvv2, *kvv3;
struct kvvec_buf *kvvb, *kvvb2;
struct kvvec k = KVVEC_INITIALIZER;
t_set_colors(0);
t_start("key/value vector tests");
kvv = kvvec_create(1);
kvv2 = kvvec_create(1);
kvv3 = kvvec_create(1);
add_vars(kvv, test_data, 1239819);
add_vars(kvv, (const char **)argv + 1, argc - 1);
kvvec_sort(kvv);
kvvec_foreach(kvv, NULL, walker);
/* kvvec2buf -> buf2kvvec -> kvvec2buf -> buf2kvvec conversion */
kvvb = kvvec2buf(kvv, KVSEP, PAIRSEP, OVERALLOC);
kvv3 = buf2kvvec(kvvb->buf, kvvb->buflen, KVSEP, PAIRSEP, KVVEC_COPY);
kvvb2 = kvvec2buf(kvv3, KVSEP, PAIRSEP, OVERALLOC);
buf2kvvec_prealloc(kvv2, kvvb->buf, kvvb->buflen, KVSEP, PAIRSEP, KVVEC_ASSIGN);
kvvec_foreach(kvv2, kvv, walker);
kvvb = kvvec2buf(kvv, KVSEP, PAIRSEP, OVERALLOC);
test(kvv->kv_pairs == kvv2->kv_pairs, "pairs should be identical");
for (i = 0; i < kvv->kv_pairs; i++) {
struct key_value *kv1, *kv2;
kv1 = &kvv->kv[i];
if (i >= kvv2->kv_pairs) {
t_fail("missing var %d in kvv2", i);
printf("[%s=%s] (%d+%d)\n", kv1->key, kv1->value, kv1->key_len, kv1->value_len);
continue;
}
kv2 = &kvv2->kv[i];
if (!test(!kv_compare(kv1, kv2), "kv pair %d must match", i)) {
printf("%d failed: [%s=%s] (%d+%d) != [%s=%s (%d+%d)]\n",
i,
kv1->key, kv1->value, kv1->key_len, kv1->value_len,
kv2->key, kv2->value, kv2->key_len, kv2->value_len);
}
}
test(kvvb2->buflen == kvvb->buflen, "buflens must match");
test(kvvb2->bufsize == kvvb->bufsize, "bufsizes must match");
if (kvvb2->buflen == kvvb->buflen && kvvb2->bufsize == kvvb->bufsize &&
!memcmp(kvvb2->buf, kvvb->buf, kvvb->bufsize))
{
t_pass("kvvec -> buf -> kvvec conversion works flawlessly");
} else {
t_fail("kvvec -> buf -> kvvec conversion failed :'(");
}
free(kvvb->buf);
free(kvvb);
free(kvvb2->buf);
free(kvvb2);
kvvec_destroy(kvv, 1);
kvvec_destroy(kvv3, KVVEC_FREE_ALL);
for (j = 0; pair_term_missing[j]; j++) {
buf2kvvec_prealloc(&k, strdup(pair_term_missing[j]), strlen(pair_term_missing[j]), '=', ';', KVVEC_COPY);
for (i = 0; i < k.kv_pairs; i++) {
struct key_value *kv = &k.kv[i];
test(kv->key_len == kv->value_len, "%d.%d; key_len=%d; value_len=%d (%s = %s)",
j, i, kv->key_len, kv->value_len, kv->key, kv->value);
test(kv->value_len == strlen(kv->value),
"%d.%d; kv->value_len(%d) == strlen(%s)(%d)",
j, i, kv->value_len, kv->value, (int)strlen(kv->value));
}
}
t_end();
return 0;
}
