slang_rs_context.h revision 6315f76e3cc6ff2d012d1183a0b030d4ff0dc808
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 14#include "slang_rs_export_element.h" 15 16namespace llvm { 17 class LLVMContext; 18 class TargetData; 19} // namespace llvm 20 21namespace clang { 22 class VarDecl; 23 class ASTContext; 24 class TargetInfo; 25 class FunctionDecl; 26 class SourceManager; 27} // namespace clang 28 29namespace slang { 30 31class RSExportVar; 32class RSExportFunc; 33class RSExportType; 34class RSPragmaHandler; 35 36class RSContext { 37 typedef llvm::StringSet<> NeedExportVarSet; 38 typedef llvm::StringSet<> NeedExportFuncSet; 39 typedef llvm::StringSet<> NeedExportTypeSet; 40 41 public: 42 typedef std::list<RSExportVar*> ExportVarList; 43 typedef std::list<RSExportFunc*> ExportFuncList; 44 typedef llvm::StringMap<RSExportType*> ExportTypeMap; 45 46 private: 47 clang::Preprocessor *mPP; 48 clang::ASTContext *mCtx; 49 const clang::TargetInfo *mTarget; 50 51 llvm::TargetData *mTargetData; 52 llvm::LLVMContext &mLLVMContext; 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 124 typedef ExportVarList::const_iterator const_export_var_iterator; 125 const_export_var_iterator export_vars_begin() const { 126 return mExportVars.begin(); 127 } 128 const_export_var_iterator export_vars_end() const { 129 return mExportVars.end(); 130 } 131 inline bool hasExportVar() const { 132 return !mExportVars.empty(); 133 } 134 135 typedef ExportFuncList::const_iterator const_export_func_iterator; 136 const_export_func_iterator export_funcs_begin() const { 137 return mExportFuncs.begin(); 138 } 139 const_export_func_iterator export_funcs_end() const { 140 return mExportFuncs.end(); 141 } 142 inline bool hasExportFunc() const { return !mExportFuncs.empty(); } 143 144 typedef ExportTypeMap::iterator export_type_iterator; 145 typedef ExportTypeMap::const_iterator const_export_type_iterator; 146 export_type_iterator export_types_begin() { return mExportTypes.begin(); } 147 export_type_iterator export_types_end() { return mExportTypes.end(); } 148 const_export_type_iterator export_types_begin() const { 149 return mExportTypes.begin(); 150 } 151 const_export_type_iterator export_types_end() const { 152 return mExportTypes.end(); 153 } 154 inline bool hasExportType() const { return !mExportTypes.empty(); } 155 export_type_iterator findExportType(const llvm::StringRef &TypeName) { 156 return mExportTypes.find(TypeName); 157 } 158 const_export_type_iterator findExportType(const llvm::StringRef &TypeName) 159 const { 160 return mExportTypes.find(TypeName); 161 } 162 163 // Insert the specified Typename/Type pair into the map. If the key already 164 // exists in the map, return false and ignore the request, otherwise insert it 165 // and return true. 166 bool insertExportType(const llvm::StringRef &TypeName, RSExportType *Type); 167 168 bool reflectToJava(const char *OutputPackageName, 169 const std::string &InputFileName, 170 const std::string &OutputBCFileName, 171 char realPackageName[], 172 int bSize); 173 bool reflectToJavaPath(const char *OutputPathName); 174 175 ~RSContext(); 176}; 177 178} // namespace slang 179 180#endif // _SLANG_COMPILER_RS_CONTEXT_H 181