void collectMyCallExprs(BaseAST* ast, Vec<CallExpr*>& callExprs,
FnSymbol* parent_fn) {
AST_CHILDREN_CALL(ast, collectMyCallExprs, callExprs, parent_fn);
if (CallExpr* callExpr = toCallExpr(ast))
if (callExpr->parentSymbol == parent_fn)
callExprs.add(callExpr);
}
void collectMyCallExprsSTL(BaseAST* ast, std::vector<CallExpr*>& callExprs,
FnSymbol* parent_fn) {
AST_CHILDREN_CALL(ast, collectMyCallExprsSTL, callExprs, parent_fn);
if (CallExpr* callExpr = toCallExpr(ast))
if (callExpr->parentSymbol == parent_fn)
callExprs.push_back(callExpr);
}
static void
view_ast(BaseAST* ast, bool number = false, int mark = -1, int indent = 0) {
if (!ast)
return;
if (Expr* expr = toExpr(ast)) {
printf("\n");
for (int i = 0; i < indent; i++)
printf(" ");
printf("(");
if (ast->id == mark)
printf("***");
if (number)
printf("%d ", ast->id);
printf("%s", expr->astTagAsString());
if (isBlockStmt(expr))
if (FnSymbol* fn = toFnSymbol(expr->parentSymbol))
if (expr == fn->where)
printf(" where");
if (GotoStmt *gs= toGotoStmt(ast)) {
printf( " ");
view_ast(gs->label, number, mark, indent+1);
}
if (CallExpr* call = toCallExpr(expr))
if (call->primitive)
printf(" %s", call->primitive->name);
if (NamedExpr* named = toNamedExpr(expr))
printf(" \"%s\"", named->name);
if (toDefExpr(expr))
printf(" ");
int64_t i;
const char *str;
if (get_int(expr, &i)) {
printf(" %" PRId64, i);
} else if (get_string(expr, &str)) {
printf(" \"%s\"", str);
}
if (SymExpr* sym = toSymExpr(expr)) {
printf(" ");
view_sym(sym->var, number, mark);
} else if (UnresolvedSymExpr* sym = toUnresolvedSymExpr(expr)) {
printf(" '%s'", sym->unresolved);
}
}
if (Symbol* sym = toSymbol(ast)) {
view_sym(sym, number, mark);
}
AST_CHILDREN_CALL(ast, view_ast, number, mark, indent+2);
if (toExpr(ast))
printf(")");
}
void collect_stmts_STL(BaseAST* ast, std::vector<Expr*>& stmts) {
if (Expr* expr = toExpr(ast)) {
stmts.push_back(expr);
if (isBlockStmt(expr) || isCondStmt(expr)) {
AST_CHILDREN_CALL(ast, collect_stmts_STL, stmts);
}
}
}
void collect_stmts(BaseAST* ast, Vec<Expr*>& stmts) {
if (Expr* expr = toExpr(ast)) {
stmts.add(expr);
if (isBlockStmt(expr) || isCondStmt(expr)) {
AST_CHILDREN_CALL(ast, collect_stmts, stmts);
}
}
}
void collectFnCalls(BaseAST* ast, Vec<CallExpr*>& calls) {
AST_CHILDREN_CALL(ast, collectFnCalls, calls);
if (CallExpr* call = toCallExpr(ast))
if (call->isResolved())
calls.add(call);
}
static void collectMySymExprsHelp(BaseAST* ast, std::vector<SymExpr*>& symExprs) {
if (isSymbol(ast)) return; // do not descend into nested symbols
AST_CHILDREN_CALL(ast, collectMySymExprsHelp, symExprs);
if (SymExpr* se = toSymExpr(ast))
symExprs.push_back(se);
}
void collect_top_asts(BaseAST* ast, Vec<BaseAST*>& asts) {
AST_CHILDREN_CALL(ast, collect_top_asts_internal, asts);
asts.add(ast);
}
void collect_asts_postorder(BaseAST* ast, Vec<BaseAST*>& asts) {
AST_CHILDREN_CALL(ast, collect_asts_postorder, asts);
asts.add(ast);
}
void collectSymbolsSTL(BaseAST* ast, std::vector<Symbol*>& symbols) {
AST_CHILDREN_CALL(ast, collectSymbolsSTL, symbols);
if (Symbol* symbol = toSymbol(ast))
symbols.push_back(symbol);
}
void collectCallExprs(BaseAST* ast, Vec<CallExpr*>& callExprs) {
AST_CHILDREN_CALL(ast, collectCallExprs, callExprs);
if (CallExpr* callExpr = toCallExpr(ast))
callExprs.add(callExpr);
}
void collectDefExprsSTL(BaseAST* ast, std::vector<DefExpr*>& defExprs) {
AST_CHILDREN_CALL(ast, collectDefExprsSTL, defExprs);
if (DefExpr* defExpr = toDefExpr(ast))
defExprs.push_back(defExpr);
}
void collectExprs(BaseAST* ast, std::vector<Expr*>& exprs) {
AST_CHILDREN_CALL(ast, collectExprs, exprs);
if (Expr* expr = toExpr(ast))
exprs.push_back(expr);
}
//
// Collect only top-level AST nodes, i.e., expressions but not
// symbols, but also includes arg symbols and types (not sure why).
// In fact, current uses of this function seem like they could be
// replaced by more specific traversals implemented in this file.
// Something to check out another day.
//
void collect_top_asts_STL(BaseAST* ast, std::vector<BaseAST*>& asts) {
AST_CHILDREN_CALL(ast, collect_top_asts_internal_STL, asts);
asts.push_back(ast);
}
static void collect_top_asts_internal_STL(BaseAST* ast, std::vector<BaseAST*>& asts) {
if (!isSymbol(ast) || isArgSymbol(ast)) {
AST_CHILDREN_CALL(ast, collect_top_asts_internal_STL, asts);
asts.push_back(ast);
}
}
void collectFnCallsSTL(BaseAST* ast, std::vector<CallExpr*>& calls) {
AST_CHILDREN_CALL(ast, collectFnCallsSTL, calls);
if (CallExpr* call = toCallExpr(ast))
if (call->isResolved())
calls.push_back(call);
}
void collect_asts_postorder_STL(BaseAST* ast, std::vector<BaseAST*>& asts) {
AST_CHILDREN_CALL(ast, collect_asts_postorder_STL, asts);
asts.push_back(ast);
}
void collectGotoStmts(BaseAST* ast, Vec<GotoStmt*>& gotoStmts) {
AST_CHILDREN_CALL(ast, collectGotoStmts, gotoStmts);
if (GotoStmt* gotoStmt = toGotoStmt(ast))
gotoStmts.add(gotoStmt);
}
void collectDefExprs(BaseAST* ast, Vec<DefExpr*>& defExprs) {
AST_CHILDREN_CALL(ast, collectDefExprs, defExprs);
if (DefExpr* defExpr = toDefExpr(ast))
defExprs.add(defExpr);
}
void collectSymbols(BaseAST* ast, Vec<Symbol*>& symbols) {
AST_CHILDREN_CALL(ast, collectSymbols, symbols);
if (Symbol* symbol = toSymbol(ast))
symbols.add(symbol);
}
void collectCallExprsSTL(BaseAST* ast, std::vector<CallExpr*>& callExprs) {
AST_CHILDREN_CALL(ast, collectCallExprsSTL, callExprs);
if (CallExpr* callExpr = toCallExpr(ast))
callExprs.push_back(callExpr);
}
// The same for std::vector.
void collectMySymExprs(Symbol* me, std::vector<SymExpr*>& symExprs) {
// skip the isSymbol(ast) check in collectMySymExprsHelp()
AST_CHILDREN_CALL(me, collectMySymExprsHelp, symExprs);
}
void collectSymExprs(BaseAST* ast, Vec<SymExpr*>& symExprs) {
AST_CHILDREN_CALL(ast, collectSymExprs, symExprs);
if (SymExpr* symExpr = toSymExpr(ast))
symExprs.add(symExpr);
}
void collectGotoStmtsSTL(BaseAST* ast, std::vector<GotoStmt*>& gotoStmts) {
AST_CHILDREN_CALL(ast, collectGotoStmtsSTL, gotoStmts);
if (GotoStmt* gotoStmt = toGotoStmt(ast))
gotoStmts.push_back(gotoStmt);
}
void collect_asts(BaseAST* ast, Vec<BaseAST*>& asts) {
asts.add(ast);
AST_CHILDREN_CALL(ast, collect_asts, asts);
}
static void
list_ast(BaseAST* ast, BaseAST* parentAst = NULL, int indent = 0) {
bool do_list_line = false;
bool is_C_loop = false;
const char* block_explain = NULL;
if (Expr* expr = toExpr(ast)) {
if (ForallStmt* pfs = toForallStmt(parentAst)) {
if (expr == pfs->fRecIterIRdef) {
printf("fRecIterIRdef");
} else if (expr == pfs->loopBody()) {
if (pfs->numShadowVars() == 0)
print_on_its_own_line(indent, "with() do\n");
else
print_on_its_own_line(indent, "do\n", false);
indent -= 2;
}
}
do_list_line = !parentAst || list_line(expr, parentAst);
if (do_list_line) {
printf("%-7d ", expr->id);
print_indent(indent);
}
if (const char* expl = forall_explanation_start(ast, parentAst))
printf("%s", expl);
if (GotoStmt* e = toGotoStmt(ast)) {
printf("goto ");
if (SymExpr* label = toSymExpr(e->label)) {
if (label->symbol() != gNil) {
list_ast(e->label, ast, indent+1);
}
} else {
list_ast(e->label, ast, indent+1);
}
} else if (toBlockStmt(ast)) {
block_explain = block_explanation(ast, parentAst);
const char* block_kind = ast->astTagAsString();
if (!strcmp(block_kind, "BlockStmt")) block_kind = "";
printf("%s{%s\n", block_explain, block_kind);
} else if (toCondStmt(ast)) {
printf("if ");
} else if (toIfExpr(ast)) {
printf("IfExpr ");
} else if (toForallStmt(ast)) {
printf("forall\n");
} else if (CallExpr* e = toCallExpr(expr)) {
if (e->isPrimitive(PRIM_BLOCK_C_FOR_LOOP))
is_C_loop = true;
if (e->primitive)
printf("%s( ", e->primitive->name);
else
printf("call( ");
} else if (ForallExpr* e = toForallExpr(expr)) {
if (e->zippered) printf("zip ");
printf("forall( ");
} else if (NamedExpr* e = toNamedExpr(expr)) {
printf("%s = ", e->name);
} else if (toDefExpr(expr)) {
Symbol* sym = toDefExpr(expr)->sym;
if (sym->type != NULL) {
printf("def %s ", sym->qualType().qualStr());
} else {
printf("def ");
}
} else if (SymExpr* e = toSymExpr(expr)) {
list_sym(e->symbol(), false);
} else if (UnresolvedSymExpr* e = toUnresolvedSymExpr(expr)) {
printf("%s ", e->unresolved);
} else if (isUseStmt(expr)) {
printf("use ");
}
}
if (Symbol* sym = toSymbol(ast))
list_sym(sym);
bool early_newline = toFnSymbol(ast) || toModuleSymbol(ast);
if (early_newline || is_C_loop)
printf("\n");
int new_indent = indent;
if (isExpr(ast))
if (do_list_line)
new_indent = indent+2;
AST_CHILDREN_CALL(ast, list_ast, ast, new_indent);
if (Expr* expr = toExpr(ast)) {
CallExpr* parent_C_loop = NULL;
if (CallExpr* call = toCallExpr(parentAst))
if (call->isPrimitive(PRIM_BLOCK_C_FOR_LOOP))
parent_C_loop = call;
if (toCallExpr(expr)) {
printf(") ");
}
if (toBlockStmt(ast)) {
printf("%-7d ", expr->id);
if (*block_explain)
indent -= 2;
print_indent(indent);
if ((parent_C_loop && parent_C_loop->get(3) == expr) || *block_explain)
printf("} ");
else if (isDeferStmt(parentAst))
printf("}"); // newline is coming
else
printf("}\n");
if (isForallLoopBody(expr) && parentAst != NULL) {
print_indent(indent);
printf(" end forall %d", parentAst->id);
}
} else if (ForallExpr* e = toForallExpr(expr)) {
if (e->cond) printf(") ");
else printf("} ");
} else if (UseStmt* use = toUseStmt(expr)) {
if (!use->isPlainUse()) {
if (use->hasExceptList()) {
printf("except ");
} else {
printf("only ");
}
bool first = true;
for_vector(const char, str, use->named) {
if (first) {
first = false;
} else {
printf(", ");
}
printf("%s", str);
}
for (std::map<const char*, const char*>::iterator it = use->renamed.begin();
it != use->renamed.end(); ++it) {
if (first) {
first = false;
} else {
printf(", ");
}
printf("%s as %s", it->second, it->first);
}
printf("\n");
}
} else if (CondStmt* cond = toCondStmt(parentAst)) {
static void collect_top_asts_internal(BaseAST* ast, Vec<BaseAST*>& asts) {
if (!isSymbol(ast) || isArgSymbol(ast)) {
AST_CHILDREN_CALL(ast, collect_top_asts_internal, asts);
asts.add(ast);
}
}
static void
list_ast(BaseAST* ast, BaseAST* parentAst = NULL, int indent = 0) {
bool do_list_line = false;
bool is_C_loop = false;
const char* block_explain = NULL;
if (Expr* expr = toExpr(ast)) {
do_list_line = !parentAst || list_line(expr, parentAst);
if (do_list_line) {
printf("%-7d ", expr->id);
for (int i = 0; i < indent; i++)
printf(" ");
}
if (GotoStmt* e = toGotoStmt(ast)) {
printf("goto ");
if (SymExpr* label = toSymExpr(e->label)) {
if (label->var != gNil) {
list_ast(e->label, ast, indent+1);
}
} else {
list_ast(e->label, ast, indent+1);
}
} else if (toBlockStmt(ast)) {
block_explain = block_explanation(ast, parentAst);
printf("%s{\n", block_explain);
} else if (toCondStmt(ast)) {
printf("if ");
} else if (CallExpr* e = toCallExpr(expr)) {
if (e->isPrimitive(PRIM_BLOCK_C_FOR_LOOP))
is_C_loop = true;
if (e->primitive)
printf("%s( ", e->primitive->name);
else
printf("call( ");
} else if (NamedExpr* e = toNamedExpr(expr)) {
printf("%s = ", e->name);
} else if (toDefExpr(expr)) {
printf("def ");
} else if (SymExpr* e = toSymExpr(expr)) {
list_sym(e->var, false);
} else if (UnresolvedSymExpr* e = toUnresolvedSymExpr(expr)) {
printf("%s ", e->unresolved);
}
}
if (Symbol* sym = toSymbol(ast))
list_sym(sym);
bool early_newline = toFnSymbol(ast) || toModuleSymbol(ast);
if (early_newline || is_C_loop)
printf("\n");
int new_indent = indent;
if (isExpr(ast))
if (do_list_line)
new_indent = indent+2;
AST_CHILDREN_CALL(ast, list_ast, ast, new_indent);
if (Expr* expr = toExpr(ast)) {
CallExpr* parent_C_loop = NULL;
if (CallExpr* call = toCallExpr(parentAst))
if (call->isPrimitive(PRIM_BLOCK_C_FOR_LOOP))
parent_C_loop = call;
if (toCallExpr(expr)) {
printf(") ");
}
if (toBlockStmt(ast)) {
printf("%-7d ", expr->id);
if (*block_explain)
indent -= 2;
for (int i = 0; i < indent; i++)
printf(" ");
if ((parent_C_loop && parent_C_loop->get(3) == expr) || *block_explain)
printf("} ");
else
printf("}\n");
} else if (CondStmt* cond = toCondStmt(parentAst)) {
if (cond->condExpr == expr)
printf("\n");
} else if (!toCondStmt(expr) && do_list_line) {
DefExpr* def = toDefExpr(expr);
if (!(def && early_newline))
if (!parent_C_loop)
printf("\n");
}
}
}
void reset_ast_loc(BaseAST* destNode, astlocT astlocArg) {
destNode->astloc = astlocArg;
AST_CHILDREN_CALL(destNode, reset_ast_loc, astlocArg);
}
void collectSymExprsSTL(BaseAST* ast, std::vector<SymExpr*>& symExprs) {
AST_CHILDREN_CALL(ast, collectSymExprsSTL, symExprs);
if (SymExpr* symExpr = toSymExpr(ast))
symExprs.push_back(symExpr);
}
