int main(int argc, char* argv[])
{
try {
// Get the filename
string input;
if(argc > 1){
input = string(argv[1]);
} else {
input = "<stdin>";
}
// Create the expression manager
Options options;
options.setInputLanguage(language::input::LANG_SMTLIB_V2);
cout << language::SetLanguage(language::output::LANG_SMTLIB_V2);
// cout << Expr::dag(0);
std::unique_ptr<api::Solver> solver =
std::unique_ptr<api::Solver>(new api::Solver(&options));
Mapper m(solver->getExprManager());
// Create the parser
ParserBuilder parserBuilder(solver.get(), input, options);
if(input == "<stdin>") parserBuilder.withStreamInput(cin);
Parser* parser = parserBuilder.build();
// Variables and assertions
vector<string> variables;
vector<string> info_tags;
vector<string> info_data;
vector<Expr> assertions;
Command* cmd = NULL;
CommandSequence commandsSequence;
bool logicisset = false;
while ((cmd = parser->nextCommand())) {
// till logic is set, don't do any modifications
if(!parser->logicIsSet()) {
cout << (*cmd) << endl;
delete cmd;
continue;
}
// transform set-logic command, if there is one
SetBenchmarkLogicCommand* setlogic = dynamic_cast<SetBenchmarkLogicCommand*>(cmd);
if(setlogic) {
LogicInfo logicinfo(setlogic->getLogic());
if(!logicinfo.isTheoryEnabled(theory::THEORY_SETS)) {
cerr << "Sets theory not enabled. Stopping translation." << endl;
return 0;
}
logicinfo = logicinfo.getUnlockedCopy();
if(enableAxioms) {
logicinfo.enableQuantifiers();
logicinfo.lock();
if(!logicinfo.hasEverything()) {
(logicinfo = logicinfo.getUnlockedCopy()).disableTheory(theory::THEORY_SETS);
logicinfo.lock();
cout << SetBenchmarkLogicCommand(logicinfo.getLogicString()) << endl;
}
} else {
logicinfo.enableTheory(theory::THEORY_ARRAYS);
// we print logic string only for Quantifiers, for Z3 stuff
// we don't set the logic
}
delete cmd;
continue;
}
// if we reach here, logic is set by now, so can define our sort
if( !logicisset ) {
logicisset = true;
m.defineSetSort();
}
// declare/define-sort commands are printed immediately
DeclareTypeCommand* declaresort = dynamic_cast<DeclareTypeCommand*>(cmd);
DefineTypeCommand* definesort = dynamic_cast<DefineTypeCommand*>(cmd);
if(declaresort || definesort) {
cout << *cmd << endl;
delete cmd;
continue;
}
// other commands are queued up, while replacing with new function symbols
AssertCommand* assert = dynamic_cast<AssertCommand*>(cmd);
DeclareFunctionCommand* declarefun = dynamic_cast<DeclareFunctionCommand*>(cmd);
DefineFunctionCommand* definefun = dynamic_cast<DefineFunctionCommand*>(cmd);
Command* new_cmd = NULL;
if(assert) {
Expr newexpr = m.collectSortsExpr(assert->getExpr());
new_cmd = new AssertCommand(newexpr);
} else if(declarefun) {
Expr newfunc = m.collectSortsExpr(declarefun->getFunction());
new_cmd = new DeclareFunctionCommand(declarefun->getSymbol(), newfunc, declarefun->getType());
} else if(definefun) {
Expr newfunc = m.collectSortsExpr(definefun->getFunction());
Expr newformula = m.collectSortsExpr(definefun->getFormula());
new_cmd = new DefineFunctionCommand(definefun->getSymbol(), newfunc, definefun->getFormals(), newformula);
}
if(new_cmd == NULL) {
commandsSequence.addCommand(cmd);
} else {
commandsSequence.addCommand(new_cmd);
delete cmd;
}
}
m.dump();
cout << commandsSequence;
// Get rid of the parser
//delete parser;
} catch (Exception& e) {
cerr << e << endl;
}
}
