int main(int argc, char* argv[]) {
std::vector<std::string> pragma_values;
SgProject* proj = frontend(argc,argv);
ROSE_ASSERT(proj != NULL);
SgFunctionDeclaration* mainDefDecl = SageInterface::findMain(proj);
SgFunctionDefinition* mainDef = mainDefDecl->get_definition();
Rose_STL_Container<SgNode*> pragmaList = NodeQuery::querySubTree(proj,V_SgPragmaDeclaration);
for (Rose_STL_Container<SgNode*>::iterator i = pragmaList.begin(); i != pragmaList.end(); i++) {
SgPragmaDeclaration* prg = isSgPragmaDeclaration(*i);
std::string prag_string = get_pragma_string(prg);
if (isSMTGeneral(prag_string)) {
std::string parsed = parseSMTGeneral(prag_string);
std::cout << ";;SMTGeneral command found: " << parsed << std::endl;
//continue;
}
else {
//std::cout << "SMTGeneral command not found" << std::endl;
std::string pos;
pos = get_position(prag_string);
if (pos == "define") {
std::cout << "define:\n";
std::vector<std::pair<std::string, std::string> > pragma_values = get_vars(prag_string);
for (std::vector<std::pair<std::string,std::string> >::iterator j = pragma_values.begin(); j != pragma_values.end(); j++) {
std::cout << (*j).first << " " << (*j).second << std::endl;
}
}
else if (pos == "assume") {
std::cout << "assume:\n";
std::vector<std::string> assumptions = get_assumptions(prag_string);
for (std::vector<std::string>::iterator i = assumptions.begin(); i != assumptions.end(); i++) {
std::cout << (*i) << std::endl;
}
}
else if (pos == "begin" || pos == "end") {
std::cout << "position: " << pos << std::endl;
}
else {
ROSE_ASSERT(false);
}
}
}
return 0;
}
int main(int argc,char** argv) {
SgProject* proj = frontend(argc,argv);
fixAllPrefixPostfix(proj);
initializeScopeInformation(proj);
SgFunctionDeclaration* mainDecl = SageInterface::findMain(proj);
SgFunctionDefinition* mainDef = mainDecl->get_definition();
//SageInterface::rebuildSymbolTable(mainDef);
StaticCFG::CFG cfg(mainDef);
SgIncidenceDirectedGraph *g = cfg.getGraph();
PathCollector* pathCollector = new PathCollector(g,&cfg);
std::vector<SgNode*> scopeNodes = NodeQuery::querySubTree(mainDef,V_SgScopeStatement);
std::vector<SgGraphNode*> visited;
std::vector<SgNode*> nodes = NodeQuery::querySubTree(mainDef,V_SgWhileStmt);
std::vector<SgNode*>::iterator node = nodes.begin();
for (; node != nodes.end(); node++) {
SgScopeStatement* scopeOfWhile = SageInterface::getEnclosingScope(*node);
SgStatementPtrList statementsInScope = scopeOfWhile->getStatementList();
SgStatementPtrList::iterator statPtr = statementsInScope.begin();
std::set<SgPragmaDeclaration*> prdecls;
for (; statPtr!=statementsInScope.end();statPtr++) {
if (isSgPragmaDeclaration(*statPtr)) {
prdecls.insert(isSgPragmaDeclaration(*statPtr));
}
}
//SgExprStatement* boundingConditionStatement = isSgExprStatement(isSgWhileStmt(*node)->get_condition());
//SgExpression* boundingCondition = boundingConditionStatement->get_expression();
SgStatement* body = (isSgWhileStmt(*node)->get_body());
std::vector<std::vector<SgGraphNode*> > paths = pathCollector->getPaths();
std::cout << getPrelude() << std::endl;
SgGraphNode* whileStart = cfg.cfgForBeginning(isSgWhileStmt(*node));
SgGraphNode* whileEnd = cfg.cfgForEnd(isSgWhileStmt(*node));
collectPaths(whileStart,whileEnd, pathCollector);
SgGraphNode* whileOut = getWhileEndNode(isSgWhileStmt(*node),pathCollector);
SgGraphNode* bodyStart = cfg.cfgForBeginning(isSgWhileStmt(*node)->get_body());
SgGraphNode* bodyEnd = cfg.cfgForEnd(isSgWhileStmt(*node)->get_body());
pathCollector->clearPaths();
collectPaths(bodyStart,whileOut,pathCollector);
paths.clear();
paths = pathCollector->getPaths();
std::vector<std::vector<SgGraphNode*> >::iterator i = paths.begin();
std::set<SgVariableSymbol*> vars = getVars(pathCollector);
std::string vardecls;
std::string initrule;
std::vector<std::string> rules= getRules(*node,pathCollector, vars, vardecls,initrule);
std::cout << vardecls << std::endl;
for (int i = 0; i < rules.size(); i++) {
std::cout << rules[i] << std::endl;
}
std::set<SgPragmaDeclaration*>::iterator pr = prdecls.begin();
for (; pr != prdecls.end(); pr++) {
std::set<std::string> variables;
std::vector<std::string> s_expressions;
std::string prag_str = get_pragma_string(*pr);
bool initPrag;
/*std::string rhs =*/ translateToS_Expr(prag_str,variables,s_expressions,initPrag);
if (s_expressions.size() > 0) {
std::string queryResult;
if (initPrag) {
queryResult = assumptionPragma(s_expressions,initrule);
}
else {
queryResult = queryPragma(s_expressions,initrule);
}
std::cout << queryResult << std::endl;
}
}
}
backend(proj);
return 0;
}
static int
do_pragma(int id, const char *name, const char *cp)
{
struct pragma_token_s token;
int err = 0;
int processed = 1;
init_pragma_token(&token);
switch (id)
{
case P_BANK:
{
struct dbuf_s buffer;
dbuf_init(&buffer, 128);
cp = get_pragma_token(cp, &token);
switch (token.type)
{
case TOKEN_EOL:
err = 1;
break;
case TOKEN_INT:
switch (_G.asmType)
{
case ASM_TYPE_ASXXXX:
dbuf_printf (&buffer, "CODE_%d", token.val.int_val);
break;
case ASM_TYPE_RGBDS:
dbuf_printf (&buffer, "CODE,BANK[%d]", token.val.int_val);
break;
case ASM_TYPE_ISAS:
/* PENDING: what to use for ISAS? */
dbuf_printf (&buffer, "CODE,BANK(%d)", token.val.int_val);
break;
default:
wassert (0);
}
break;
default:
{
const char *str = get_pragma_string (&token);
dbuf_append_str (&buffer, (0 == strcmp("BASE", str)) ? "HOME" : str);
}
break;
}
cp = get_pragma_token (cp, &token);
if (TOKEN_EOL != token.type)
{
err = 1;
break;
}
dbuf_c_str (&buffer);
/* ugly, see comment in src/port.h (borutr) */
gbz80_port.mem.code_name = dbuf_detach (&buffer);
code->sname = gbz80_port.mem.code_name;
options.code_seg = (char *)gbz80_port.mem.code_name;
}
break;
case P_PORTMODE:
{ /*.p.t.20030716 - adding pragma to manipulate z80 i/o port addressing modes */
const char *str;
cp = get_pragma_token (cp, &token);
if (TOKEN_EOL == token.type)
{
err = 1;
break;
}
str = get_pragma_string (&token);
cp = get_pragma_token (cp, &token);
if (TOKEN_EOL != token.type)
{
err = 1;
break;
}
if (!strcmp(str, "z80"))
{ z80_opts.port_mode = 80; }
else if(!strcmp(str, "z180"))
{ z80_opts.port_mode = 180; }
else if(!strcmp(str, "save"))
{ z80_opts.port_back = z80_opts.port_mode; }
else if(!strcmp(str, "restore" ))
{ z80_opts.port_mode = z80_opts.port_back; }
else
err = 1;
}
break;
case P_CODESEG:
case P_CONSTSEG:
{
char *segname;
cp = get_pragma_token (cp, &token);
if (token.type == TOKEN_EOL)
{
err = 1;
break;
}
segname = Safe_strdup (get_pragma_string(&token));
cp = get_pragma_token (cp, &token);
if (token.type != TOKEN_EOL)
{
Safe_free (segname);
err = 1;
break;
}
if (id == P_CODESEG)
{
if (options.code_seg) Safe_free(options.code_seg);
options.code_seg = segname;
}
else
{
if (options.const_seg) Safe_free(options.const_seg);
options.const_seg = segname;
}
}
break;
default:
processed = 0;
break;
}
get_pragma_token(cp, &token);
if (1 == err)
werror(W_BAD_PRAGMA_ARGUMENTS, name);
free_pragma_token(&token);
return processed;
}
