slang_rs_context.h revision b81c6a4cbd9c08e0b20ea4fbc615b416ac1bc9ec
1#ifndef _SLANG_COMPILER_RS_CONTEXT_H
2#define _SLANG_COMPILER_RS_CONTEXT_H
3
4#include <map>
5#include <list>
6#include <string>
7#include <cstdio>
8
9#include "llvm/ADT/StringSet.h"
10#include "llvm/ADT/StringMap.h"
11
12#include "clang/Lex/Preprocessor.h"
13
14namespace llvm {
15  class LLVMContext;
16  class TargetData;
17}   // namespace llvm
18
19namespace clang {
20  class VarDecl;
21  class ASTContext;
22  class TargetInfo;
23  class FunctionDecl;
24  class SourceManager;
25}   // namespace clang
26
27namespace slang {
28  class RSExportable;
29  class RSExportVar;
30  class RSExportFunc;
31  class RSExportType;
32
33class RSContext {
34  typedef llvm::StringSet<> NeedExportVarSet;
35  typedef llvm::StringSet<> NeedExportFuncSet;
36  typedef llvm::StringSet<> NeedExportTypeSet;
37
38 public:
39  typedef std::list<RSExportable*> ExportableList;
40  typedef std::list<RSExportVar*> ExportVarList;
41  typedef std::list<RSExportFunc*> ExportFuncList;
42  typedef llvm::StringMap<RSExportType*> ExportTypeMap;
43
44 private:
45  clang::Preprocessor *mPP;
46  clang::ASTContext *mCtx;
47  const clang::TargetInfo *mTarget;
48
49  llvm::TargetData *mTargetData;
50  llvm::LLVMContext &mLLVMContext;
51
52  ExportableList mExportables;
53
54  // Record the variables/types/elements annotated in #pragma to be exported
55  NeedExportVarSet mNeedExportVars;
56  NeedExportFuncSet mNeedExportFuncs;
57  NeedExportTypeSet mNeedExportTypes;
58  bool mExportAllNonStaticVars;
59  bool mExportAllNonStaticFuncs;
60
61  std::string *mLicenseNote;
62  std::string mReflectJavaPackageName;
63  std::string mReflectJavaPathName;
64
65  bool processExportVar(const clang::VarDecl *VD);
66  bool processExportFunc(const clang::FunctionDecl *FD);
67  bool processExportType(const llvm::StringRef &Name);
68
69  ExportVarList mExportVars;
70  ExportFuncList mExportFuncs;
71  ExportTypeMap mExportTypes;
72
73 public:
74  RSContext(clang::Preprocessor *PP,
75            clang::ASTContext *Ctx,
76            const clang::TargetInfo *Target);
77
78  inline clang::Preprocessor *getPreprocessor() const { return mPP; }
79  inline clang::ASTContext *getASTContext() const { return mCtx; }
80  inline const llvm::TargetData *getTargetData() const { return mTargetData; }
81  inline llvm::LLVMContext &getLLVMContext() const { return mLLVMContext; }
82  inline const clang::SourceManager *getSourceManager() const {
83    return &mPP->getSourceManager();
84  }
85
86  inline void setLicenseNote(const std::string &S) {
87    mLicenseNote = new std::string(S);
88  }
89  inline const std::string *getLicenseNote() const { return mLicenseNote; }
90
91  inline void addExportVar(const std::string &S) {
92    mNeedExportVars.insert(S);
93    return;
94  }
95  inline void addExportFunc(const std::string &S) {
96    mNeedExportFuncs.insert(S);
97    return;
98  }
99  inline void addExportType(const std::string &S) {
100    mNeedExportTypes.insert(S);
101    return;
102  }
103
104  inline void setExportAllNonStaticVars(bool flag) {
105    mExportAllNonStaticVars = flag;
106  }
107  inline void setExportAllNonStaticFuncs(bool flag) {
108    mExportAllNonStaticFuncs = flag;
109  }
110  inline void setReflectJavaPackageName(const std::string &S) {
111    mReflectJavaPackageName = S;
112    return;
113  }
114
115  void processExport();
116  inline void newExportable(RSExportable *E) {
117    if (E != NULL)
118      mExportables.push_back(E);
119  }
120
121  typedef ExportVarList::const_iterator const_export_var_iterator;
122  const_export_var_iterator export_vars_begin() const {
123    return mExportVars.begin();
124  }
125  const_export_var_iterator export_vars_end() const {
126    return mExportVars.end();
127  }
128  inline bool hasExportVar() const {
129    return !mExportVars.empty();
130  }
131
132  typedef ExportFuncList::const_iterator const_export_func_iterator;
133  const_export_func_iterator export_funcs_begin() const {
134    return mExportFuncs.begin();
135  }
136  const_export_func_iterator export_funcs_end() const {
137    return mExportFuncs.end();
138  }
139  inline bool hasExportFunc() const { return !mExportFuncs.empty(); }
140
141  typedef ExportTypeMap::iterator export_type_iterator;
142  typedef ExportTypeMap::const_iterator const_export_type_iterator;
143  export_type_iterator export_types_begin() { return mExportTypes.begin(); }
144  export_type_iterator export_types_end() { return mExportTypes.end(); }
145  const_export_type_iterator export_types_begin() const {
146    return mExportTypes.begin();
147  }
148  const_export_type_iterator export_types_end() const {
149    return mExportTypes.end();
150  }
151  inline bool hasExportType() const { return !mExportTypes.empty(); }
152  export_type_iterator findExportType(const llvm::StringRef &TypeName) {
153    return mExportTypes.find(TypeName);
154  }
155  const_export_type_iterator findExportType(const llvm::StringRef &TypeName)
156      const {
157    return mExportTypes.find(TypeName);
158  }
159
160  // Insert the specified Typename/Type pair into the map. If the key already
161  // exists in the map, return false and ignore the request, otherwise insert it
162  // and return true.
163  bool insertExportType(const llvm::StringRef &TypeName, RSExportType *Type);
164
165  bool reflectToJava(const std::string &OutputPathBase,
166                     const std::string &OutputPackageName,
167                     const std::string &InputFileName,
168                     const std::string &OutputBCFileName,
169                     std::string *RealPackageName);
170
171  ~RSContext();
172};
173
174}   // namespace slang
175
176#endif  // _SLANG_COMPILER_RS_CONTEXT_H
177