int main( int argc, char *argv[] )
{
(void) argc;
(void) argv;
arbitrary();
random_insertions();
size_test();
iter_test();
clear_test();
return 0;
}
precedence * mk_precedence(ast_manager & m, order_params const & params) {
if (params.m_order_precedence_gen.empty())
return mk_default_precedence(m, params);
symbol user("user");
symbol definition("definition");
symbol interpreted("interpreted");
symbol frequency("frequency");
symbol arity("arity");
symbol arbitrary("arbitrary");
symbol inv("-");
ptr_buffer<precedence> ps;
svector<symbol>::const_iterator it = params.m_order_precedence_gen.begin();
svector<symbol>::const_iterator end = params.m_order_precedence_gen.end();
bool prev_inv = false;
for (; it != end; ++it) {
symbol curr = *it;
if (curr == user) {
if (params.m_order_precedence.empty())
ps.push_back(mk_inv_precedence(prev_inv, alloc(user_precedence, m, params.m_order_precedence.size(), params.m_order_precedence.c_ptr())));
}
else if (curr == definition) {
warning_msg("definition precedence was not implement yet.");
}
else if (curr == interpreted) {
ps.push_back(mk_inv_precedence(prev_inv, alloc(interpreted_precedence)));
}
else if (curr == frequency) {
warning_msg("frequency precedence was not implement yet.");
}
else if (curr == arity) {
ps.push_back(mk_inv_precedence(prev_inv, alloc(arity_precedence)));
}
else if (curr == arbitrary) {
ps.push_back(mk_inv_precedence(prev_inv, alloc(arbitrary_precedence)));
// it is pointless to continue, arbitrary_precedence is a total order
return mk_lex_precedence(ps);
}
else if (curr == inv) {
prev_inv = true;
}
else {
warning_msg("invalid precedence generator: ignoring atom '%s'.", curr.bare_str());
}
}
return mk_lex_precedence(ps);
}
void arbitrary(NwaRefPtr & nwa, int n)
{
assert(nwa == 0);
int num_states;
arbitrary(num_states, n);
num_states = abs(num_states);
std::vector<wali::Key> state_keys(num_states);
nwa = new Nwa(wali::getKey("stuck"));
for (int i=0; i<num_states; ++i) {
std::stringstream ss;
ss << "state #" << i;
wali::Key key = wali::getKey(ss.str());
nwa->addState(key);
state_keys[i] = key;
}
int num_syms;
arbitrary(num_syms, n/2);
num_syms = abs(num_syms);
std::vector<wali::Key> sym_keys(num_syms);
for (int i=0; i<num_syms; ++i) {
std::stringstream ss;
ss << "symbol #" << i;
wali::Key key = wali::getKey(ss.str());
nwa->addSymbol(key);
sym_keys[i] = key;
}
// Internals
for (int i=0; i<num_states; ++i) {
for (int j=0; j<num_states; ++j) {
for (int k=0; k<num_syms; ++k) {
bool inc;
arbitrary(inc, 0);
if (inc) {
nwa->addInternalTrans(state_keys[i], sym_keys[k], state_keys[j]);
}
}
}
}
// Calls
for (int i=0; i<num_states; ++i) {
for (int j=0; j<num_states; ++j) {
for (int k=0; k<num_syms; ++k) {
bool inc;
arbitrary(inc, 0);
if (inc) {
nwa->addCallTrans(state_keys[i], sym_keys[k], state_keys[j]);
}
}
}
}
// Returns
for (int i=0; i<num_states; ++i) {
for (int j=0; j<num_states; ++j) {
for (int k=0; k<num_states; ++k) {
for (int l=0; l<num_syms; ++l) {
bool inc;
arbitrary(inc, 0);
if (inc) {
nwa->addReturnTrans(state_keys[i], state_keys[j], sym_keys[l], state_keys[k]);
}
}
}
}
}
}
