void DisassemblerContext::print_exists(const ValuePtr<Exists>& term, bool bracket) {
if (bracket)
*m_output << '(';
*m_output << "exists (";
unsigned n_parameters = term->parameter_types().size();
unsigned parameter_name_base = m_parameter_name_index;
m_parameter_name_index += n_parameters;
boost::format name_formatter("%%%s");
m_parameter_names.push_back(ParameterNameList::value_type());
ParameterNameList::value_type& name_list = m_parameter_names.back();
for (unsigned ii = 0; ii != n_parameters; ++ii) {
if (ii)
*m_output << ", ";
std::string name = str(name_formatter % (parameter_name_base + ii));
*m_output << name << " : ";
print_term(term->parameter_types()[ii], false);
name_list.push_back(name);
}
*m_output << ") > ";
print_term(term->result(), true);
m_parameter_names.pop_back();
m_parameter_name_index = parameter_name_base;
if (bracket)
*m_output << ')';
}
void DisassemblerContext::setup_term(const ValuePtr<>& term) {
if (!m_visited_terms.insert(term).second)
return;
setup_term_name(term);
switch (term->term_type()) {
case term_apply: {
ValuePtr<ApplyType> apply = value_cast<ApplyType>(term);
setup_term(apply->recursive());
for (std::vector<ValuePtr<> >::const_iterator ii = apply->parameters().begin(), ie = apply->parameters().end(); ii != ie; ++ii)
setup_term(*ii);
break;
}
case term_exists: {
ValuePtr<Exists> exists = value_cast<Exists>(term);
setup_term(exists->result());
break;
}
case term_parameter_placeholder:
case term_recursive_parameter: {
setup_term(term->type());
break;
}
case term_functional: {
class MyVisitor : public FunctionalValueVisitor {
DisassemblerContext *m_self;
public:
MyVisitor(DisassemblerContext *self) : m_self(self) {}
virtual void next(const ValuePtr<>& v) {if (v) m_self->setup_term(v);}
};
MyVisitor my_visitor(this);
value_cast<FunctionalValue>(term)->functional_visit(my_visitor);
break;
}
case term_function_type: {
ValuePtr<FunctionType> cast_term = value_cast<FunctionType>(term);
const std::vector<ParameterType>& parameter_types = cast_term->parameter_types();
for (std::vector<ParameterType>::const_iterator ii = parameter_types.begin(), ie = parameter_types.end(); ii != ie; ++ii)
setup_term(ii->value);
setup_term(cast_term->result_type().value);
break;
}
default:
return; // Skip adding to definition list
}
if (TermDefinitionList *dl = term_definition_list(term))
dl->push_back(term);
}
void DisassemblerContext::print_recursive(const ValuePtr<RecursiveType>& term) {
*m_output << "recursive (";
boost::format name_formatter("%%%s");
for (RecursiveType::ParameterList::const_iterator ib = term->parameters().begin(), ii = term->parameters().begin(), ie = term->parameters().end(); ii != ie; ++ii) {
if (ii != ib)
*m_output << ", ";
*m_output << name(*ii) << " : ";
print_term((*ii)->type(), false);
}
*m_output << ") > ";
if (term->result())
print_term(term->result(), true);
else
*m_output << "NULL";
*m_output << ";\n";
}
void DisassemblerContext::setup_term_definition(const ValuePtr<>& term) {
if (!m_defined_terms.insert(term).second)
return;
setup_term_name(term);
switch (term->term_type()) {
case term_recursive: {
ValuePtr<RecursiveType> recursive = value_cast<RecursiveType>(term);
for (RecursiveType::ParameterList::const_iterator ii = recursive->parameters().begin(), ie = recursive->parameters().end(); ii != ie; ++ii) {
setup_term_name(*ii);
setup_term((*ii)->type());
}
if (recursive->result())
setup_term(recursive->result());
break;
}
case term_global_variable: {
ValuePtr<GlobalVariable> gvar = value_cast<GlobalVariable>(term);
setup_term(gvar->value_type());
if (gvar->value())
setup_term(gvar->value());
break;
}
case term_function: {
ValuePtr<Function> function = value_cast<Function>(term);
setup_function(function);
break;
}
case term_function_parameter: {
ValuePtr<FunctionParameter> param = value_cast<FunctionParameter>(term);
setup_term(param->type());
break;
}
case term_instruction: {
class MyVisitor : public InstructionVisitor {
DisassemblerContext *m_self;
public:
MyVisitor(DisassemblerContext *self) : m_self(self) {}
virtual void next(ValuePtr<>& v) {if (v) m_self->setup_term(v);}
};
MyVisitor my_visitor(this);
ValuePtr<Instruction> insn = value_cast<Instruction>(term);
insn->instruction_visit(my_visitor);
m_local_definitions[insn->block()].push_back(insn);
break;
}
case term_phi: {
ValuePtr<Phi> phi = value_cast<Phi>(term);
const std::vector<PhiEdge>& edges = phi->edges();
for (std::vector<PhiEdge>::const_iterator ii = edges.begin(), ie = edges.end(); ii != ie; ++ii) {
setup_term(ii->block);
setup_term(ii->value);
}
break;
}
default:
setup_term(term);
break;
}
}