3 #define _SAGEGENERIC_H 1
16 #if __cplusplus >= 201103L
17 #include <type_traits>
27 #define WITH_BINARY_ANALYSIS 0
34 #define SG_UNEXPECTED_NODE(X) (sg::unexpected_node(X, __FILE__, __LINE__))
35 #define SG_DEREF(X) (sg::deref(X, __FILE__, __LINE__))
36 #define SG_ASSERT_TYPE(SAGENODE, N) (sg::assert_sage_type<SAGENODE>(N, __FILE__, __LINE__))
37 #define SG_ERROR_IF(COND, MSG) (sg::report_error_if(COND, MSG, __FILE__, __LINE__))
48 void unused(
const T&) {}
51 template <
class T1,
class T2>
57 template <
class T1,
class T2>
60 typedef const T2 type;
67 template <
class T,
class E>
82 void report_error(std::string desc,
const char* file = 0,
size_t ln = 0)
86 const std::string at(
" at ");
87 const std::string sep(
" : ");
88 const std::string num(conv<std::string>(ln));
90 desc = desc + at + file + sep + num;
93 std::cerr << desc << std::endl;
94 throw std::logic_error(desc);
98 void report_error_if(
bool iserror,
const std::string& desc,
const char* file = 0,
size_t ln = 0)
100 if (!iserror)
return;
102 report_error(desc, file, ln);
107 T& deref(T* ptr,
const char* file = 0,
size_t ln = 0)
109 report_error_if(!ptr,
"null dereference ", file, ln);
114 void unexpected_node(
const SgNode& n,
const char* file = 0,
size_t ln = 0)
116 static const std::string msg =
"unexpected node-type: ";
118 report_error(msg +
typeid(n).name(), file, ln);
131 template <
class _ReturnType>
134 typedef _ReturnType ReturnType;
146 operator ReturnType()
const {
return res; }
157 template <
class SageNode>
159 SageNode& assume_sage_type(
SgNode& n)
161 return static_cast<SageNode&
>(n);
166 template <
class SageNode>
168 const SageNode& assume_sage_type(
const SgNode& n)
170 return static_cast<const SageNode&
>(n);
173 #define GEN_VISIT(X) \
174 void visit(X * n) { rv.handle(*n); }
176 template <
class RoseVisitor>
180 #if __cplusplus >= 201103L
183 : rv(std::move(rosevisitor))
1165 #if __cplusplus >= 201103L
1166 template <
class RoseVisitor>
1168 typename std::remove_const<typename std::remove_reference<RoseVisitor>::type>::type
1169 _dispatch(RoseVisitor&& rv,
SgNode* n)
1171 typedef typename std::remove_reference<RoseVisitor>::type RoseVisitorNoref;
1172 typedef typename std::remove_const<RoseVisitorNoref>::type RoseHandler;
1177 std::is_lvalue_reference<RoseVisitor>()
1181 return std::move(vis).rv;
1184 template <
class RoseVisitor>
1187 _dispatch(
const RoseVisitor& rv,
SgNode* n)
1191 VisitDispatcher<RoseVisitor> vis(rv);
1267 #if __cplusplus >= 201103L
1268 template <
class RoseVisitor>
1270 typename std::remove_const<typename std::remove_reference<RoseVisitor>::type>::type
1271 dispatch(RoseVisitor&& rv,
SgNode* n)
1274 return _dispatch(std::forward<RoseVisitor>(rv), n);
1277 template <
class RoseVisitor>
1279 typename std::remove_const<typename std::remove_reference<RoseVisitor>::type>::type
1280 dispatch(RoseVisitor&& rv,
const SgNode* n)
1283 return _dispatch(std::forward<RoseVisitor>(rv), const_cast<SgNode*>(n));
1286 template <
class RoseVisitor>
1289 dispatch(
const RoseVisitor& rv,
SgNode* n)
1291 return _dispatch(rv, n);
1295 template <
class RoseVisitor>
1298 dispatch(
const RoseVisitor& rv,
const SgNode* n)
1300 return _dispatch(rv, const_cast<SgNode*>(n));
1313 template <
class SageNode>
1316 void handle(SageNode&) {}
1326 template <
class AncestorNode,
class QualSgNode>
1330 typedef std::pair<AncestorNode*, QualSgNode*> Pair;
1335 : Base(), res(NULL, NULL)
1342 void handle(QualSgNode& n) { res.second = n.get_parent(); }
1343 void handle(AncestorNode& n) { res.first = &n; }
1345 operator Pair()
const {
return res; }
1350 template <
class AncestorNode,
class QualSgNode>
1351 AncestorNode* _ancestor(QualSgNode& n)
1355 typename AncestorFinder::Pair res(NULL, n.get_parent());
1357 while (res.second != NULL)
1359 res = (
typename AncestorFinder::Pair) sg::dispatch(AncestorFinder(), res.second);
1376 template <
class AncestorNode>
1377 AncestorNode* ancestor(
SgNode* n)
1379 if (n == NULL)
return NULL;
1381 return _ancestor<AncestorNode>(*n);
1385 template <
class AncestorNode>
1386 const AncestorNode* ancestor(
const SgNode* n)
1388 if (n == NULL)
return NULL;
1390 return _ancestor<const AncestorNode>(*n);
1394 template <
class AncestorNode>
1395 AncestorNode& ancestor(
SgNode& n)
1397 AncestorNode* res = _ancestor<AncestorNode>(n);
1404 template <
class AncestorNode>
1405 const AncestorNode& ancestor(
const SgNode& n)
1407 const AncestorNode* res = _ancestor<const AncestorNode>(n);
1414 template <
class SageNode>
1415 struct TypeRecoveryHandler
1417 typedef typename ConstLike<SageNode, SgNode>::type SgBaseNode;
1419 TypeRecoveryHandler(
const char* f = 0,
size_t ln = 0)
1420 : res(NULL), loc(f), loc_ln(ln)
1423 #if __cplusplus >= 201103L
1424 TypeRecoveryHandler(TypeRecoveryHandler&&) =
default;
1426 TypeRecoveryHandler() =
delete;
1427 TypeRecoveryHandler(
const TypeRecoveryHandler&) =
delete;
1428 TypeRecoveryHandler& operator=(
const TypeRecoveryHandler&) =
delete;
1429 TypeRecoveryHandler& operator=(TypeRecoveryHandler&&) =
delete;
1431 operator SageNode* ()&& {
return res; }
1433 operator SageNode* () {
return res; }
1436 void handle(SgBaseNode& n) { unexpected_node(n, loc, loc_ln); }
1437 void handle(SageNode& n) { res = &n; }
1453 template <
class SageNode>
1454 SageNode* assert_sage_type(
SgNode* n,
const char* f = 0,
size_t ln = 0)
1456 return sg::dispatch(TypeRecoveryHandler<SageNode>(f, ln), n);
1459 template <
class SageNode>
1460 const SageNode* assert_sage_type(
const SgNode* n,
const char* f = 0,
size_t ln = 0)
1462 return sg::dispatch(TypeRecoveryHandler<const SageNode>(f, ln), n);
1465 template <
class SageNode>
1466 SageNode& assert_sage_type(
SgNode& n,
const char* f = 0,
size_t ln = 0)
1468 return *sg::dispatch(TypeRecoveryHandler<SageNode>(f, ln), &n);
1471 template <
class SageNode>
1472 const SageNode& assert_sage_type(
const SgNode& n,
const char* f = 0,
size_t ln = 0)
1474 return *sg::dispatch(TypeRecoveryHandler<const SageNode>(f, ln), &n);
1493 void swap_parent(
void*,
void*) {}
1502 template <
class SageNode,
class SageChild>
1503 void swap_child(SageNode& lhs, SageNode& rhs, SageChild* (SageNode::*getter) ()
const,
void (SageNode::*setter) (SageChild*))
1505 SageChild* lhs_child = (lhs.*getter)();
1506 SageChild* rhs_child = (rhs.*getter)();
1507 ROSE_ASSERT(lhs_child && rhs_child);
1509 (lhs.*setter)(rhs_child);
1510 (rhs.*setter)(lhs_child);
1512 swap_parent(lhs_child, rhs_child);
1518 template <
class SageNode>
1521 typedef void (*TransformHandlerFn)(SageNode*);
1529 void handle(SageNode& n) { fn(&n); }
1531 TransformHandlerFn fn;
1536 template <
class SageNode>
1539 createTraversalFunction(
void (* fn)(SageNode*))
1549 template <
class GVisitor>
1560 gvisitor = sg::dispatch(gvisitor, n);
1564 GVisitor visitor() {
return gvisitor; }
1580 forAllNodes(F fn,
SgNode* root, AstSimpleProcessing::Order order = postorder)
1584 TraversalClass<F> tt(fn);
1587 tt.traverse(root, order);
1588 return tt.visitor();
1591 template <
class SageNode>
1594 forAllNodes(
void (*fn)(SageNode*),
SgNode* root, AstSimpleProcessing::Order order = postorder)
1596 forAllNodes(createTransformExecutor(fn), root, order);
1599 #if !defined(NDEBUG)
1601 std::string nodeType(
const SgNode& n)
1603 return typeid(n).name();
1607 std::string nodeType(
const SgNode* n)
1609 if (n == NULL)
return "<null>";
1611 return nodeType(*n);
1615 template <
class GVisitor>
1618 #if __cplusplus >= 201103L
1621 : gvisitor(std::move(gv)), parent(p), cnt(0)
1626 : gvisitor(gv), parent(p), cnt(0)
1630 void operator()(
SgNode* n)
1637 std::cerr <<
"succ(" << nodeType(parent) <<
", " << cnt <<
") is null" << std::endl;
1642 #if __cplusplus >= 201103L
1643 if (n != NULL) gvisitor = sg::dispatch(std::move(gvisitor), n);
1645 if (n != NULL) gvisitor = sg::dispatch(gvisitor, n);
1649 #if __cplusplus >= 201103L
1650 operator GVisitor()&& {
return std::move(gvisitor); }
1652 operator GVisitor() {
return gvisitor; }
1661 template <
class GVisitor>
1664 dispatchHelper(GVisitor gv,
SgNode* parent = NULL)
1666 #if __cplusplus >= 201103L
1674 template <
class GVisitor>
1676 GVisitor traverseChildren(GVisitor gv,
SgNode& n)
1680 #if __cplusplus >= 201103L
1681 return std::for_each(successors.begin(), successors.end(), dispatchHelper(std::move(gv), &n));
1683 return std::for_each(successors.begin(), successors.end(), dispatchHelper(gv, &n));
1687 template <
class GVisitor>
1689 GVisitor traverseChildren(GVisitor gv,
SgNode* n)
1691 return traverseChildren(gv, sg::deref(n));
This class represents modifiers for SgDeclaration (declaration statements).
This class represents the notion of an initializer for a variable declaration or expression in a func...
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
This class represents the concept of a C++ template instantiation directive.
This class represents the concept of an instantiation of member function template or a member functio...
This class represents the concept of a class declaration statement. It includes the concept of an ins...
This class represents the concept of a declaration list.
This class represents a boolean value (expression value).
This class represents a OLD concept of the structure require for qualified names when they were in th...
This class represents the notion of an n-ary comparison operation. This node is intended for use with...
This class represents the concept of an instantiated class template.
This class represents the notion of an value (expression value).
This class represents the concept of a C or C++ goto statement.
This class represents the concept of the dynamic execution of a string, file, or code object...
This class represents the concept of a C or C++ statement which contains a expression.
This class represents the notion of a binary operator. It is derived from a SgExpression because oper...
This class represents a source file for a project (which may contian many source files and or directo...
This class represents the variable declaration or variable initialization withn a for loop...
This class represents the concept of a C++ sequence of catch statements.
This class represents the notion of a unary operator. It is derived from a SgExpression because opera...
This class represents the GNU extension "statement expression" (thus is non-standard C and C++)...
Class for traversing the AST.
This class represents the C++ throw expression (handled as a unary operator).
This class represents the rhs of a variable declaration which includes an optional assignment (e...
This class represents the concept of a C++ using directive.
This class represents the base class for all types.
This class represents the concept of a do-while statement.
This class represents a Fortran pointer assignment. It is not some weird compound assignment operator...
This class represents the concept of a class name within the compiler.
This class represents the location of the code associated with the IR node in the original source cod...
This class represents the concept of an enum declaration.
This class represents the "this" operator (can be applied to any member data).
void set_parent(SgNode *parent)
All nodes in the AST contain a reference to a parent node.
This class represents a string type used for SgStringVal IR node.
This class represents the notion of an n-ary boolean operation. This node is intended for use with Py...
This class represents the concept of a C style extern "C" declaration. But such information (linkage)...
This class represents the notion of a declared variable.
This class represents the concept of a member function declaration statement.
This class represents the concept of a C and C++ case option (used within a switch statement)...
This class represents the concept of a function declaration statement.
This class represents the concept of a C Assembler statement (untested).
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
This class represents the notion of an n-ary operator. This node is intended for use with Python...
This class represents the concept of a C and C++ expression list.
This class represents the "sizeof()" operator (applied to any type).
This class represents the concept of a C++ namespace alias declaration statement. ...
This class is not used in ROSE, but is intended to represent a list of SgModifierTypes (similar to th...
This class represents the base class of a numbr of IR nodes that don't otherwise fit into the existin...
This class represents a directory within a projects file structure of files and directories.
This class represents the notion of an value (expression value).
This class represents the concept of a C trinary conditional expression (e.g. "test ...
This class represents the notion of an expression. Expressions are derived from SgLocatedNodes, since similar to statement, expressions have a concrete location within the user's source code.
void visit(SgNode *n)
this method is called at every traversed node.
This class represents the notion of a break statement (typically used in a switch statment)...
This class represents the concept of a name within the compiler.
executes a functor for a specific node type
This class represents the concept of a class definition in C++.
This class represents strings within the IR nodes.
projects the constness of T1 on T2
This class is intended to be a wrapper around SgStatements, allowing them to exist in scopes that onl...
This class represents the concept of a contructor initializer list (used in constructor (member funct...
This class represents the concept of a namespace name within the compiler.
This class represents the notion of a typedef declaration.
This class represents the notion of an value (expression value).
This class represents the base class for all IR nodes within Sage III.
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
This class represents the notion of an value (expression value).
This class represents the concept of a variable name within the compiler (a shared container for the ...
This class represents a lambda expression.
This class represents the concept of an instantiation of function template.
This class represents the physical disequality (often called pointer disequality) operator for langua...
This class represents the "&" operator (applied to any lvalue).
This class represents the conversion of an arbitrary expression to a string. This node is intended fo...
This class represents the base class of a number of IR nodes define modifiers within the C++ grammar...
This class represents the concept of a block (not a basic block from control flow analysis)...
This class represents the concept of a C++ namespace declaration.
This class represents a list display.
This class represents the notion of a statement.
This class represents the concept of a namespace definition.
This class represents the concept of a for loop.
This class represents the physical equality (often called pointer equality) operator for languages th...
This class represents the concept of a C++ using declaration.
This class represents a C99 complex type.
This class represents a tuple display.
This class represents a type for all functions.
This class represents the concept of a namespace definition.
This class represents the numeric negation of a value. Not to be confused with SgSubtractOp.
This class represents the concept of a C Assembler statement (untested).
This class represents the concept of a C or C++ default case within a switch statement.
This class represents a default type used for some IR nodes (see below).
This class represents the concept of an "if" construct.
virtual std::vector< SgNode * > get_traversalSuccessorContainer()
container of pointers to AST successor nodes used in the traversal overridden in every class by gener...
This class represents the concept of a template declaration.
This class represents the notion of an expression or statement which has a position within the source...
This class represents template argument within the use of a template to build an instantiation.
This class represents the variable refernece in expressions.
This class represents the concept of a do-while statement.
This class represents a OLD concept of the structure require for qualified names when they were in th...
This class represents the definition (initialization) of a variable.
This class represents the concept of a class definition in C++.
This class represents the concept of a C++ call to the delete operator.
virtual void accept(ROSE_VisitorPattern &visitor)
support for the classic visitor pattern done in GoF
helper class for _ancestor
This class represents the concept of a C++ call to the new operator.
This class represents the concept of a C or C++ continue statement.
This class represents an object used to initialize the unparsing.
This class represents the member function being called and must be assembled in the SgFunctionCall wi...
This class represents modifiers specific to storage.
This class represents the symbol tables used in both SgScopeStatement and the SgFunctionTypeSymbolTab...
SgNode * get_parent() const
Access function for parent node.
This class represents the function being called and must be assembled in the SgFunctionCall with the ...
This class represents the concept of try statement within the try-catch support for exception handlin...
This class represents the concept of a name and a type. It may be renamed in the future to SgTypeSymb...
This class represents a list of associated typedefs for the SgType IR nodes which reference this list...
This class represents a source project, with a list of SgFile objects and global information about th...
This class represents the concept of a 'global' stmt in Python.
This class represents the function type table (stores all function types so that they can be shared i...
This class represents a C99 complex type.
This class represents the concept of a C or C++ variable declaration.
This class represents the notion of an initializer for a variable declaration or expression in a func...
This class represents the concept of a C or C++ label statement.
This class is part of the older CC++ concept. It is not a part of C or C++ (this IR node is not used ...
This class represents the concept of a C++ function call (which is an expression).
This class was part of CC++ support from a long time ago.
This class represents the concept of a declaration statement.
This class represents the concept of a generic call expression.
This class represents the concept of a switch.
This class represents the concept of a C++ expression built from a class name.
