int main(int argc, char* argv[])
{
// Get the filename
string input(argv[1]);
// Create the expression manager
Options options;
options.set(inputLanguage, language::input::LANG_SMTLIB_V2);
ExprManager exprManager(options);
// Create the parser
ParserBuilder parserBuilder(&exprManager, input, options);
Parser* parser = parserBuilder.build();
// Variables and assertions
std::map<Expr, unsigned> variables;
vector<string> info_tags;
vector<string> info_data;
vector<Expr> assertions;
Command* cmd;
while ((cmd = parser->nextCommand())) {
SetInfoCommand* setinfo = dynamic_cast<SetInfoCommand*>(cmd);
if (setinfo) {
info_tags.push_back(setinfo->getFlag());
info_data.push_back(setinfo->getSExpr().getValue());
delete cmd;
continue;
}
DeclareFunctionCommand* declare = dynamic_cast<DeclareFunctionCommand*>(cmd);
if (declare) {
string name = declare->getSymbol();
Expr var = parser->getVariable(name);
unsigned n = variables.size();
variables[var] = n;
delete cmd;
continue;
}
AssertCommand* assert = dynamic_cast<AssertCommand*>(cmd);
if (assert) {
assertions.push_back(assert->getExpr());
delete cmd;
continue;
}
delete cmd;
}
// Do the translation
translate_to_mathematica(input, info_tags, info_data, variables, assertions);
// Get rid of the parser
delete parser;
}
int main(int argc, char* argv[])
{
// Get the filename
string input(argv[1]);
// Create the expression manager
Options options;
options.setInputLanguage(language::input::LANG_SMTLIB_V2);
options.setOutputLanguage(language::output::LANG_SMTLIB_V2);
std::unique_ptr<api::Solver> solver =
std::unique_ptr<api::Solver>(new api::Solver(&options));
cout << expr::ExprDag(0) << expr::ExprSetDepth(-1);
// Create the parser
ParserBuilder parserBuilder(solver.get(), input, options);
Parser* parser = parserBuilder.build();
// Variables and assertions
std::map<Expr, unsigned> variables;
vector<string> info_tags;
vector<string> info_data;
vector<Expr> assertions;
Command* cmd;
while ((cmd = parser->nextCommand())) {
DeclareFunctionCommand* declare = dynamic_cast<DeclareFunctionCommand*>(cmd);
if (declare) {
cout << "[-10000, 10000] " << declare->getSymbol() << ";" << endl;
}
AssertCommand* assert = dynamic_cast<AssertCommand*>(cmd);
if (assert) {
cout << assert->getExpr() << ";" << endl;
}
delete cmd;
}
// Get rid of the parser
delete parser;
}
int main(int argc, char* argv[])
{
try {
// Get the filename
string input(argv[1]);
// Create the expression manager
Options options;
options.set(inputLanguage, language::input::LANG_SMTLIB_V2);
ExprManager exprManager(options);
// Create the parser
ParserBuilder parserBuilder(&exprManager, input, options);
Parser* parser = parserBuilder.build();
// Variables and assertions
vector<string> variables;
vector<string> info_tags;
vector<string> info_data;
vector<Expr> assertions;
Command* cmd;
while ((cmd = parser->nextCommand())) {
SetInfoCommand* setinfo = dynamic_cast<SetInfoCommand*>(cmd);
if (setinfo) {
info_tags.push_back(setinfo->getFlag());
info_data.push_back(setinfo->getSExpr().getValue());
delete cmd;
continue;
}
DeclareFunctionCommand* declare = dynamic_cast<DeclareFunctionCommand*>(cmd);
if (declare) {
variables.push_back(declare->getSymbol());
delete cmd;
continue;
}
AssertCommand* assert = dynamic_cast<AssertCommand*>(cmd);
if (assert) {
assertions.push_back(assert->getExpr());
delete cmd;
continue;
}
delete cmd;
}
cout << "variables: " << variables.size() << endl;
unsigned total_degree = 0;
for (unsigned i = 0; i < assertions.size(); ++ i) {
total_degree = std::max(total_degree, compute_degree(exprManager, assertions[i]));
}
cout << "degree: " << total_degree << endl;
// Get rid of the parser
delete parser;
} catch (Exception& e) {
cerr << e << endl;
}
}
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;
}
}
