slang_rs_context.h revision 6791df284557f4173a9715b3634f4f4901a6bb8a
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