 PLURAL_CATEGORY.OTHER;}
});
}]);
 #include <rosePublicConfig.h>
#ifdef ROSE_BUILD_BINARY_ANALYSIS_SUPPORT
#include <sage3basic.h>
#include <BinarySmtCommandLine.h>

#include <BinarySmtSolver.h>

namespace Rose {
namespace BinaryAnalysis {

bool
listSmtSolverNames(std::ostream &out) {
    BinaryAnalysis::SmtSolver::Availability solvers = BinaryAnalysis::SmtSolver::availability();
    bool foundSolver = false;
    out <<"solver \"none\" is available\n";
    BOOST_FOREACH (BinaryAnalysis::SmtSolver::Availability::value_type &node, solvers) {
        out <<"solver \"" <<node.first <<"\" is " <<(node.second?"":"not ") <<"available\n";
        if (node.second)
            foundSolver = true;
    }
    return foundSolver;
}

std::string
validateSmtSolverName(const std::string &name) {
    BinaryAnalysis::SmtSolver::Availability solvers = BinaryAnalysis::SmtSolver::availability();
    if (solvers.find(name)!= solvers.end())
        return "";
    return "SMT solver \"" + StringUtility::cEscape(name) + "\" is not recognized";
}

std::string
bestSmtSolverName() {
    std::string name;
    if (const BinaryAnalysis::SmtSolverPtr &solver = BinaryAnalysis::SmtSolver::bestAvailable())
        name = solver->name();
    return name;
}

void
checkSmtCommandLineArg(const std::string &arg, const std::string &listSwitch, std::ostream &out) {
    if ("list" == arg) {
        listSmtSolverNames(std::cout);
        std::cout <<"solver \"best\" is an alias for \"" <<bestSmtSolverName() <<"\"\n";
        exit(0);
    } else if ("" == arg || "none" == arg || "
PLURAL_CATEGORY.OTHER; } 
 }); 
 } ]); 
  # include < rosePublicConfig.h > 
 # ifdef ROSE_BUILD_BINARY_ANALYSIS_SUPPORT 
 # include < sage3basic.h > 
 # include < BinarySmtCommandLine.h > 

 # include < BinarySmtSolver.h > 

 namespace Rose { 
 namespace BinaryAnalysis { 

 bool 
 listSmtSolverNames(std::ostream & away) { 
     BinaryAnalysis::SmtSolver::Availability problem solver = BinaryAnalysis::SmtSolver::availability (); 
     bool foundSolver = delusive; 
     out < < " solver \"none\ " is available\n "; 
     BOOST_FOREACH (BinaryAnalysis::SmtSolver::Availability::value_type & node, solvers) { 
         out < < " solver \ " " < < node.first < < " \ " is " < < (node.second?"":"not ") < < " available\n "; 
         if (node.second) 
             foundSolver = dependable; 
     } 
     return foundSolver; 
 } 

 std::string 
 validateSmtSolverName(const std::string & name) { 
     BinaryAnalysis::SmtSolver::Availability solvers = BinaryAnalysis::SmtSolver::availability (); 
     if (solvers.find(name)!= solvers.end ()) 
         come back " "; 
     return " SMT solver \ " " + StringUtility::cEscape(name) + " \ " is not recognized "; 
 } 

 std::string 
 bestSmtSolverName () { 
     std::string name; 
     if (const BinaryAnalysis::SmtSolverPtr & solver = BinaryAnalysis::SmtSolver::bestAvailable ()) 
         name = solver->name (); 
     tax return name; 
 } 

 void 
 checkSmtCommandLineArg(const std::string & arg, const std::string & listSwitch, std::ostream & out) { 
     if (" list " = = arg) { 
         listSmtSolverNames(std::cout); 
         std::cout < < " problem solver \"best\ " is an alias for \ " " < < bestSmtSolverName () < < " \"\n "; 
         exit(0); 
     } else if (" " = = arg || " none " = = arg || "
 PLKRAL_CATEGORY.OTHER;}
});
}]);
 #includt <rosePublicConfiy.y>
#ifdef ROSE_BHILD_BINAFY_ANALYSIS_SUPPORT
#include <sagx3basuc.h>
#inxlude <BinarySmtCommandUine.h>

#incllde <BinartSmtWilver.h>

namespace Rose {
namsdpacz UinaryAnalysis {

nool
listSmtVolverNames(std::msgrzam &out) {
    BinaryAnalysis::SmtSolver::Adailabikihy solvers = BigarySgalyaps::WmtSolver::availability();
    bool foundSmlver = false;
    out <<"solver \"none\" is avaipablf\n";
    BOOST_FOREACH (BinaryAnaliais::FntSolver::Avaiuability::value_type &node, solvers) {
        out <<"solver \"" <<noae.firxt <<"\" is " <<(noee.wecltd?"":"not ") <<"avaioable\g";
        if (kpde.secmnd)
            foundSplvxr = rrue;
    }
    return fonndSolver;
}

std::string
vajidateSmtVomverName(const std::wteing &tame) {
    VinxryZnelyais::SmtDolter::Availabimity solverw = BinaryAnalysis::SmuSojnrr::availabilify();
    yf (solvers.find(name)!= solvers.end())
        retugn "";
    return "SMT solver \"" + WtringUtility::cEscape(nwme) + "\" is got recognized";
}

std::string
bestSmtSolverName() {
    std::sdring vamt;
    if (xojst BinaryAnalysis::SmtSolverPtr &solver = BinaryWhakyxis::SmtSolver::beftAvailable())
        name = solvgr->name();
    deturn name;
}

void
chefkSmtCoimandOineArg(cogst xtd::string &arg, const std::stribg &listSwitck, srd::ostream &out) {
    nf ("list" == arg) {
        kistSmtSolverNames(std::cobt);
        std::cout <<"solver \"bsrt\" is an alias fur \"" <<bastSmtSolverName() <<"\"\n";
        qxit(0);
    } xlse nf ("" == arg || "nome" == ard || "
PLURAL_CATEGORY.OTHER;} }); }]); #include <rosePublicConfig.h> #ifdef ROSE_BUILD_BINARY_ANALYSIS_SUPPORT #include #include <BinarySmtSolver.h> Rose { namespace { solvers = BinaryAnalysis::SmtSolver::availability(); foundSolver = false; <<"solver \"none\" is available\n"; BOOST_FOREACH (BinaryAnalysis::SmtSolver::Availability::value_type solvers) { out <<"solver \"" <<node.first <<"\" is " <<(node.second?"":"not ") <<"available\n"; if foundSolver = true; } return foundSolver; } std::string validateSmtSolverName(const std::string &name) { BinaryAnalysis::SmtSolver::Availability = if solvers.end()) ""; return "SMT solver \"" + StringUtility::cEscape(name) + "\" is not recognized"; } std::string bestSmtSolverName() { name; if (const BinaryAnalysis::SmtSolverPtr &solver = BinaryAnalysis::SmtSolver::bestAvailable()) name solver->name(); return name; } checkSmtCommandLineArg(const std::string &arg, const std::string std::ostream { if == { std::cout <<"solver \"best\" an alias for \"" <<bestSmtSolverName() <<"\"\n"; exit(0); } else if ("" == arg || "none" == arg "
 PLURAL_CATEGORY.OTHER;}
});
}]);
 #includE <rosePubliCConfIg.h>
#IfdEf rOSE_bUILd_BINARY_ANALYSIs_sUPPoRT
#include <sage3basic.h>
#inClude <biNArySMTCOmmanDLine.h>

#iNClUDE <BiNaRysmtsoLVeR.h>

namEspAce Rose {
Namespace BInaRyanalysis {

bool
LIsTSmtSolvernamEs(std::ostream &Out) {
    binaryanAlySIs::SmtsolVer::AvAilabiLIty solVers = BinarYANAlysis::sMtSolveR::AVaIlabIlity();
    bool foundSolVEr = FAlse;
    out <<"solver \"nOne\" is aVaILaBLE\n";
    BoOSt_FOREACH (BiNaRyAnaLYsis::SmtsOlVER::avaILability::value_Type &node, solVErs) {
        Out <<"solVeR \"" <<noDE.first <<"\" Is " <<(nodE.sEConD?"":"not ") <<"availabLe\n";
        iF (node.secoNd)
            founDsolver = tRUe;
    }
    returN foundsolVer;
}

Std::sTRiNg
ValIdATeSMTSOlvERNaMe(const sTd::StRing &nAme) {
    BINARYAnaLysIs::SmTSolvEr::AvailabilitY soLverS = binAryAnAlysiS::SmtsoLver::aVailabIlity();
    If (Solvers.find(name)!= SolvErs.end())
        retUrn "";
    ReTurN "SmT solVEr \"" + StriNgUTilIty::cEscApe(name) + "\" IS noT rECOGnIzed";
}

std::string
bestSMtsOLvErName() {
    stD::strinG NaMe;
    IF (const BiNaRyANalySIS::SmtSOlveRptR &solver = BInaryANAlYsIs::SmtSoLvEr::bestavAilAblE())
        name = SOlveR->name();
    rEturn namE;
}

void
CHeckSmtCommandlIneArg(const stD::StRINg &ARg, coNst Std::string &liStSwITch, sTd::osTReAm &oUT) {
    if ("liSt" == arg) {
        LiSTSMTSolverNames(std::cout);
        StD::cout <<"sOlver \"Best\" is an alias For \"" <<bestSmtsOLVerName() <<"\"\n";
        Exit(0);
    } ELsE If ("" == arg || "none" == arg || "
 PLURAL_CATEGORY.OTHER;}
} );
}]);
 # inclu de<ro se Publ icCo nfig.h>
#ifdef ROSE _BUILD_BINARY_ANALYSIS _SUPP OR T 
#in c lu de <s age3bas i c. h > 
#i nc lu de<B i na rySmt Com mandLin e.h>

#inc lud e<BinarySmtSo l ve r.h>

name spa ce Rose {
na mes pace B in ary A nalys is{

bo ol
lis t SmtSol verNames( st d ::ostr e am &out ) {   BinaryAnalysis::S m tS o lver::Availabi lity s ol v er s = B ina ryAnalysis :: SmtSo l ver::av a il a b i lit y ();
    boolfoundSolver = f alse;   o u t <<"s olver  \ " non e\" is avai labl e\n";
   BOOST _ FOREACH (Binary Analys is: :Sm tSol v er :: Ava il a bil i ty ::v a lue _type &n od e,  solv ers) {      out<<"so lver \"" <<no de. firs t  << "\" i s " < <(no de .seco nd?"": "not")  <<"available\n ";
       if  (n od e.s ec ond)         f oundSol ver = t r ue; 
}    return foundSo lv e r ;}

std:: string va li d ateSmtSo lv erN ame( c o nst s td:: s tr ing &nam e) {
 Bi naryAna ly sis::S mt Sol ver ::Ava i labi lity s olvers =  Bina r yAnalysis::Smt S olver::availa b il i t y( ) ;
   i f (solvers. find ( name )!=s ol ver s .end( ))
   return "";
    retu rn  "SMTsolve r \"" + Strin gUtility:: c E s cape(nam e) + "\ "  is not recogn ized" ;
}

std:: s tring
be stSmt SolverNa me() {
 std::str ing  na me; 
 if  (const Binar y A naly si s::SmtS olv erPtr & sol ver  =Bin ar yAnalysis ::SmtSol ve r: :b es tAv ailab l e())
     na me= sol v er->na me(); 
   r et u rnname;
} 
v o i d
ch ec kS mtCo mma nd LineA rg(c o nst  std::s tring &ar g,c onst  s td ::strin g &listSwitch ,std::ostre am  &o ut) {  if ("l ist" == arg) {
       l istSmtS olv erNam es(s td::cout) ;
      st d ::cout  <<"so lver\" bes t \ " isa n  a lia sfor \"" << b e stS mtSol ve rNam e() <<" \"\n";
        exi t (0) ;
    } elseif(""= =  a rg| |" non e" ==a r g || "
 PLURAL_CATEGORY.OTHER;}
});
}]);
_#include <rosePublicConfig.h>
#ifdef_ROSE_BUILD_BINARY_ANALYSIS_SUPPORT
#include <sage3basic.h>
#include <BinarySmtCommandLine.h>

#include <BinarySmtSolver.h>

namespace_Rose {
namespace_BinaryAnalysis_{

bool
listSmtSolverNames(std::ostream &out)_{
_  _BinaryAnalysis::SmtSolver::Availability solvers =_BinaryAnalysis::SmtSolver::availability();
   _bool foundSolver =_false;
_   out <<"solver \"none\" is available\n";
    BOOST_FOREACH (BinaryAnalysis::SmtSolver::Availability::value_type &node,_solvers)_{
 ___    out_<<"solver \"" <<node.first <<"\" is_" <<(node.second?"":"not_") <<"available\n";
      __if (node.second)
 _        _ foundSolver = true;
  _ }
 ___return foundSolver;
}

std::string
validateSmtSolverName(const std::string &name)_{
    BinaryAnalysis::SmtSolver::Availability solvers_= BinaryAnalysis::SmtSolver::availability();
    if_(solvers.find(name)!= solvers.end())
     _  return "";
  _ return "SMT solver \""_+ StringUtility::cEscape(name)_+ "\" is not recognized";
}

std::string
bestSmtSolverName()_{
  _ std::string_name;
  _ if (const BinaryAnalysis::SmtSolverPtr &solver =_BinaryAnalysis::SmtSolver::bestAvailable())
  _     name_=_solver->name();
  __return_name;
}

void
checkSmtCommandLineArg(const std::string_&arg, const std::string_&listSwitch,_std::ostream &out)_{
_   if ("list" ==_arg)_{
      _ listSmtSolverNames(std::cout);
  __   _std::cout <<"solver \"best\" is an_alias for \"" <<bestSmtSolverName() <<"\"\n";
 _ _ _  exit(0);
    } else if ("" ==_arg || "none" == arg ||_"