ROSE  0.11.109.0
Factory.h
1 #ifndef ROSE_CodeGen_Factory_H
2 #define ROSE_CodeGen_Factory_H
3 
4 #include <Rose/CodeGen/API.h>
5 
6 namespace Rose { namespace CodeGen {
7 
17 template <typename CRT, typename API>
18 class Factory;
19 
28 template <typename CRT, typename apiT, Object otag>
30 
31 using tplargs_t = std::vector<SgTemplateArgument *>;
32 
33 template <typename CRT, typename API>
34 class Factory {
35  public:
36  using factory_t = Factory<CRT, API>;
37 
38  public:
39  Driver & driver;
40  API api;
41 
42  public:
43  Factory(Driver & driver_) : driver(driver_), api() {
44  api.load(driver);
45  }
46 
60  template <Object otag, typename... Args>
61  declaration_t<otag> * instantiate(symbol_t<otag> * API::* obj, SgNamedType * parent, Args... args) const {
62  symbol_t<otag> * sym = api.*obj;
63  ROSE_ASSERT(sym);
64  ROSE_ASSERT(is_template_symbol_variant<otag>(sym->variantT()));
65  return __factory_helper_t<CRT, API, otag>::instantiate(*this, sym, parent, args...);
66  }
67 
81  template <Object otag, typename... Args>
82  reference_t<otag> * reference(symbol_t<otag> * API::* obj, SgNamedType * parent, Args... args) const {
83  symbol_t<otag> * sym = api.*obj;
84  ROSE_ASSERT(sym);
85 
86  if (is_template_symbol_variant<otag>(sym->variantT())) {
87  declaration_t<otag> * decl = instantiate<otag>(obj, parent, args...);
88  ROSE_ASSERT(decl != nullptr);
89  sym = dynamic_cast<symbol_t<otag> *>(decl->search_for_symbol_from_symbol_table());
90  ROSE_ASSERT(sym != nullptr);
91 // ROSE_ASSERT(sym->get_declaration() == decl->get_firstNondefiningDeclaration());
92  } else {
93  // FIXME sanity-check: `args` is empty
94  }
95 
96  return __factory_helper_t<CRT, API, otag>::reference(*this, sym, parent, args...);
97  }
98 
112  template <Object otag, typename... Args>
113  SgExpression * access(symbol_t<otag> * API::* obj, SgExpression * parent, Args... args) const {
114 
115  SgType * ptype = parent->get_type(); // TODO strip type modifiers and references
116 
117  bool lhs_has_ptr_type = isSgPointerType(parent->get_type());
118  if (lhs_has_ptr_type) {
119  ptype = ((SgPointerType*)ptype)->get_base_type(); // TODO strip type modifiers and references
120  }
121 
122  SgClassType * xtype = isSgClassType(ptype);
123  ROSE_ASSERT(xtype != nullptr);
124 
125  reference_t<otag> * rhs = reference(obj, ptype, args...);
126  ROSE_ASSERT(rhs != nullptr);
127 
128  if (lhs_has_ptr_type) {
129  return SageBuilder::buildArrowExp(parent, rhs);
130  } else {
131  return SageBuilder::buildDotExp(parent, rhs);
132  }
133  }
134 
135 
136  protected:
143  template <Object otag>
144  using access_return_t = std::conditional_t<otag == Object::a_class || otag == Object::a_typedef, SgType, SgExpression>;
145 
146 
147  public:
159  template <Object otag, typename... Args>
160  access_return_t<otag> * access(symbol_t<otag> * API::* obj, SgNamedType * parent, Args... args) const {
161  reference_t<otag> * rhs = reference(obj, parent, args...);
162  // TODO build either SgScopedRefType SgScopedRefExp
163  return rhs;
164  }
165 };
166 
167 #if 0
168 template <typename CRT, typename apiT>
169 template <>
170 reference_t<Object::a_variable> * Factory<CRT,apiT>::reference<Object::a_variable>(symbol_t<Object::a_variable> * sym) {
171  return nullptr;
172 }
173 #endif
174 
175 } }
176 
177 #include "Rose/CodeGen/factory/namespaces.txx"
178 #include "Rose/CodeGen/factory/classes.txx"
179 #include "Rose/CodeGen/factory/typedefs.txx"
180 #include "Rose/CodeGen/factory/variables.txx"
181 #include "Rose/CodeGen/factory/functions.txx"
182 
183 #endif
constructs expressions and types for the given API
Definition: Factory.h:18
This class represents the base class for all types.
access_return_t< otag > * access(symbol_t< otag > *API::*obj, SgNamedType *parent, Args...args) const
Build expression or type to access static member and subtype of the parent type.
Definition: Factory.h:160
typename object_helper< otag >::symbol_t symbol_t
The SgSymbol specialization for an Object kind /tparam otag an Object kind.
Definition: Object.h:26
virtual SgType * get_type() const
unparsing support for pragmas
permits to gather types and symbols to extract an API from a set of headers.
Definition: API.h:17
Main namespace for the ROSE library.
facilitates the manipulation of source-files (esp.
Definition: Driver.h:21
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.
Object
The five kind of objects manipulated by Rose::CodeGen::API and associated Rose::CodeGen::Factory.
Definition: Object.h:11
reference_t< otag > * reference(symbol_t< otag > *API::*obj, SgNamedType *parent, Args...args) const
Return an expression or type referencing the object.
Definition: Factory.h:82
enables partial specializations w.r.t the template parameter otag
Definition: Factory.h:29
typename object_helper< otag >::decl_t declaration_t
The SgDeclarationStatement specialization for an Object kind /tparam otag an Object kind...
Definition: Object.h:38
SgExpression * access(symbol_t< otag > *API::*obj, SgExpression *parent, Args...args) const
Build expression to access a member of the parent expression.
Definition: Factory.h:113
ROSE_DLL_API SgArrowExp * buildArrowExp(SgExpression *lhs=NULL, SgExpression *rhs=NULL)
ROSE_DLL_API SgDotExp * buildDotExp(SgExpression *lhs=NULL, SgExpression *rhs=NULL)
declaration_t< otag > * instantiate(symbol_t< otag > *API::*obj, SgNamedType *parent, Args...args) const
Return an instantiation.
Definition: Factory.h:61
typename object_helper< otag >::ref_t reference_t
The SgReference specialization for an Object kind /tparam otag an Object kind.
Definition: Object.h:32
std::conditional_t< otag==Object::a_class||otag==Object::a_typedef, SgType, SgExpression > access_return_t
Select return type for access based on Object type.
Definition: Factory.h:144