slang_rs_context.h revision a6d60672695f1438a63acdbf85eae7f97ce2b50d
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  inline void setReflectJavaPathName(const std::string &S) {
115    mReflectJavaPathName = S;
116    return;
117  }
118  inline std::string getReflectJavaPathName() const {
119    return mReflectJavaPathName;
120  }
121
122  void processExport();
123  inline void newExportable(RSExportable *E) {
124    if (E != NULL)
125      mExportables.push_back(E);
126  }
127
128  typedef ExportVarList::const_iterator const_export_var_iterator;
129  const_export_var_iterator export_vars_begin() const {
130    return mExportVars.begin();
131  }
132  const_export_var_iterator export_vars_end() const {
133    return mExportVars.end();
134  }
135  inline bool hasExportVar() const {
136    return !mExportVars.empty();
137  }
138
139  typedef ExportFuncList::const_iterator const_export_func_iterator;
140  const_export_func_iterator export_funcs_begin() const {
141    return mExportFuncs.begin();
142  }
143  const_export_func_iterator export_funcs_end() const {
144    return mExportFuncs.end();
145  }
146  inline bool hasExportFunc() const { return !mExportFuncs.empty(); }
147
148  typedef ExportTypeMap::iterator export_type_iterator;
149  typedef ExportTypeMap::const_iterator const_export_type_iterator;
150  export_type_iterator export_types_begin() { return mExportTypes.begin(); }
151  export_type_iterator export_types_end() { return mExportTypes.end(); }
152  const_export_type_iterator export_types_begin() const {
153    return mExportTypes.begin();
154  }
155  const_export_type_iterator export_types_end() const {
156    return mExportTypes.end();
157  }
158  inline bool hasExportType() const { return !mExportTypes.empty(); }
159  export_type_iterator findExportType(const llvm::StringRef &TypeName) {
160    return mExportTypes.find(TypeName);
161  }
162  const_export_type_iterator findExportType(const llvm::StringRef &TypeName)
163      const {
164    return mExportTypes.find(TypeName);
165  }
166
167  // Insert the specified Typename/Type pair into the map. If the key already
168  // exists in the map, return false and ignore the request, otherwise insert it
169  // and return true.
170  bool insertExportType(const llvm::StringRef &TypeName, RSExportType *Type);
171
172  bool reflectToJava(const char *OutputPackageName,
173                     const std::string &InputFileName,
174                     const std::string &OutputBCFileName,
175                     char realPackageName[],
176                     int bSize);
177  bool reflectToJavaPath(const char *OutputPathName);
178
179  ~RSContext();
180};
181
182}   // namespace slang
183
184#endif  // _SLANG_COMPILER_RS_CONTEXT_H
185