void collect_symbols(var_symbol_list & vs,const expression * e)
{
if(const func_term * f = dynamic_cast<const func_term*>(e))
{
for(parameter_symbol_list::const_iterator i = f->getArgs()->begin();
i != f->getArgs()->end();++i)
{
if(var_symbol* v = const_cast<var_symbol*>(dynamic_cast<const var_symbol*>(*i)))
{
if(find(vs.begin(),vs.end(),v)==vs.end()) vs.push_back(v);
}
else
{
cerr << "Handle constants in duration constraints manually, please\n";
exit(1);
};
};
}
else
{
if(const binary_expression * b = dynamic_cast<const binary_expression*>(e))
{
collect_symbols(vs,b->getLHS());
collect_symbols(vs,b->getRHS());
}
else if(const uminus_expression * u = dynamic_cast<const uminus_expression*>(e))
{
collect_symbols(vs,u->getExpr());
};
};
};
void
xref_output()
{
Symbol **symbols, *symp;
size_t i, num;
num = collect_symbols(&symbols, is_var, 0);
qsort(symbols, num, sizeof(*symbols), compare);
/* produce xref output */
for (i = 0; i < num; i++) {
symp = symbols[i];
switch (symp->type) {
case SymIdentifier:
print_function(symp);
break;
case SymToken:
print_type(symp);
break;
case SymUndefined:
break;
}
}
free(symbols);
}
static void
tree_output()
{
Symbol **symbols, *main_sym;
int i, num;
/* Collect and sort symbols */
num = collect_symbols(&symbols, is_var);
qsort(symbols, num, sizeof(*symbols), compare);
/* Scan and mark the recursive ones */
for (i = 0; i < num; i++) {
if (symbols[i]->callee)
scan_tree(0, symbols[i]);
}
/* Produce output */
begin();
if (reverse_tree) {
for (i = 0; i < num; i++) {
inverted_tree(0, 0, symbols[i]);
separator();
}
} else {
main_sym = lookup(start_name);
if (main_sym) {
direct_tree(0, 0, main_sym);
separator();
} else {
for (i = 0; i < num; i++) {
if (symbols[i]->callee == NULL)
continue;
direct_tree(0, 0, symbols[i]);
separator();
}
}
}
end();
free(symbols);
}
static void
tree_output()
{
Symbol **symbols, *main_sym;
size_t i, num;
cflow_depmap_t depmap;
/* Collect functions and assign them ordinal numbers */
num = collect_functions(&symbols);
for (i = 0; i < num; i++)
symbols[i]->ord = i;
/* Create a dependency matrix */
depmap = depmap_alloc(num);
for (i = 0; i < num; i++) {
if (symbols[i]->callee) {
struct linked_list_entry *p;
for (p = linked_list_head(symbols[i]->callee); p;
p = p->next) {
Symbol *s = (Symbol*) p->data;
if (symbol_is_function(s))
depmap_set(depmap, i, ((Symbol*)p->data)->ord);
}
}
}
depmap_tc(depmap);
/* Mark recursive calls */
for (i = 0; i < num; i++)
if (depmap_isset(depmap, i, i))
symbols[i]->recursive = 1;
free(depmap);
free(symbols);
/* Collect and sort all symbols */
num = collect_symbols(&symbols, is_var, 0);
qsort(symbols, num, sizeof(*symbols), compare);
/* Produce output */
begin();
if (reverse_tree) {
for (i = 0; i < num; i++) {
inverted_tree(0, 0, symbols[i]);
separator();
}
} else {
main_sym = lookup(start_name);
if (main_sym) {
direct_tree(0, 0, main_sym);
separator();
} else {
for (i = 0; i < num; i++) {
if (symbols[i]->callee == NULL)
continue;
direct_tree(0, 0, symbols[i]);
separator();
}
}
}
end();
free(symbols);
}
void LPGPTranslator::write_durative_action(ostream & o,const durative_action * p)
{
// This is the important one in LPGP translation. The key is that we need to
// output multiple action schemas -- this requires setting of a filter switch and
// invocation of the output three times.
time_spec filters[3] = {E_AT_START,E_OVER_ALL,E_AT_END};
string ends[3] = {"-start","-inv1","-end"};
for(int i = 0; i < 3;++i)
{
filter = filters[i];
o << "(:action " << p->name->getName() << ends[i] << "\n :parameters (";
p->parameters->var_symbol_list::write(o);
if(i != 1)
{
o << ")\n :duration (" << p->name->getName();
timed_goal * tg = dynamic_cast<timed_goal*>(p->dur_constraint);
const comparison * c = 0;
if(tg) c = dynamic_cast<const comparison *>(tg->getGoal());
if(c)
{
var_symbol_list vs;
collect_symbols(vs,c);
vs.var_symbol_list::write(o);
if(i==0)
{
duration_expressions.push_back(
duration_expression(p->name->getName(),vs,c->getRHS()));
};
}
else
{
cerr << "Can't handle complex duration constraints\n";
p->dur_constraint->write(o);
exit(1);
};
};
o << ")\n :precondition\n\t(and ";
if(conj_goal * cg = dynamic_cast<conj_goal*>(p->precondition))
{
o << *(cg->getGoals());
}
else
{
o << *(p->precondition);
};
if(i > 0)
{
o << " (" << p->name->getName() << "ing-inv ";
p->parameters->var_symbol_list::write(o);
o << ")\n";
};
if(i > 1)
{
o << " (i" << p->name->getName() << "ing-inv ";
p->parameters->var_symbol_list::write(o);
o << ")\n";
};
o << ")\n :effect (and\n\t";
for_each(p->effects->add_effects.begin(),p->effects->add_effects.end(),Writer(o));
for_each(p->effects->del_effects.begin(),p->effects->del_effects.end(),NotWriter(o));
for_each(p->effects->forall_effects.begin(),p->effects->forall_effects.end(),Writer(o));
for_each(p->effects->cond_effects.begin(),p->effects->cond_effects.end(),Writer(o));
for_each(p->effects->assign_effects.begin(),p->effects->assign_effects.end(),Writer(o));
for_each(p->effects->timed_effects.begin(),p->effects->timed_effects.end(),Writer(o));
if(i < 2)
{
o << " (" << p->name->getName() << "ing-inv ";
p->parameters->var_symbol_list::write(o);
o << ")\n";
};
if(i == 1)
{
o << " (i" << p->name->getName() << "ing-inv ";
p->parameters->var_symbol_list::write(o);
o << ")\n";
};
if(i == 2)
{
o << " (not (" << p->name->getName() << "ing-inv ";
p->parameters->var_symbol_list::write(o);
o << "))\n (not (i" << p->name->getName() << "ing-inv ";
p->parameters->var_symbol_list::write(o);
o << "))\n";
};
o << "))\n\n";
};
};
