slang_rs_reflection_cpp.h revision f9d5d13e26c451c192ea3b45137cfa685196a64c 
1/*
2 * Copyright 2012, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_REFLECTION_CPP_H_  // NOLINT
18#define _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_REFLECTION_CPP_H_
19
20#include "slang_rs_reflect_utils.h"
21
22#include <set>
23#include <string>
24
25#define RS_EXPORT_VAR_PREFIX "mExportVar_"
26
27namespace slang {
28
29class RSReflectionCpp {
30 public:
31  RSReflectionCpp(const RSContext *Context, const std::string &OutputDirectory,
32                  const std::string &RSSourceFileName,
33                  const std::string &BitCodeFileName);
34  virtual ~RSReflectionCpp();
35
36  bool reflect();
37
38 private:
39  // List of of (type, name) pairs.
40  typedef std::vector<std::pair<std::string, std::string> > ArgumentList;
41
42  // Information coming from the compiler about the code we're reflecting.
43  const RSContext *mRSContext;
44
45  // Path to the *.rs file for which we're generating C++ code.
46  std::string mRSSourceFilePath;
47  // Path to the file that contains the byte code generated from the *.rs file.
48  std::string mBitCodeFilePath;
49  // The directory where we'll generate the C++ files.
50  std::string mOutputDirectory;
51  // A cleaned up version of the *.rs file name that can be used in generating
52  // C++ identifiers.
53  std::string mCleanedRSFileName;
54  // The name of the generated C++ class.
55  std::string mClassName;
56
57  // TODO document
58  unsigned int mNextExportVarSlot;
59  unsigned int mNextExportFuncSlot;
60  unsigned int mNextExportForEachSlot;
61
62  // Generated RS Elements for type-checking code.
63  std::set<std::string> mTypesToCheck;
64
65  inline void clear() {
66    mNextExportVarSlot = 0;
67    mNextExportFuncSlot = 0;
68    mNextExportForEachSlot = 0;
69    mTypesToCheck.clear();
70  }
71
72  // The file we are currently generating, either the header or the
73  // implementation file.
74  GeneratedFile mOut;
75
76  void genInitValue(const clang::APValue &Val, bool asBool = false);
77  static const char *getVectorAccessor(unsigned index);
78
79  inline unsigned int getNextExportVarSlot() { return mNextExportVarSlot++; }
80
81  inline unsigned int getNextExportFuncSlot() { return mNextExportFuncSlot++; }
82
83  inline unsigned int getNextExportForEachSlot() {
84    return mNextExportForEachSlot++;
85  }
86
87  bool writeHeaderFile();
88  bool writeImplementationFile();
89  void makeFunctionSignature(bool isDefinition, const RSExportFunc *ef);
90  bool genEncodedBitCode();
91  void genFieldsToStoreExportVariableValues();
92  void genTypeInstancesUsedInForEach();
93  void genFieldsForAllocationTypeVerification();
94  void genExportVariablesGetterAndSetter();
95  void genForEachDeclarations();
96  void genExportFunctionDeclarations();
97
98  bool startScriptHeader();
99
100  // Write out code for an export variable initialization.
101  void genInitExportVariable(const RSExportType *ET, const std::string &VarName,
102                             const clang::APValue &Val);
103  void genZeroInitExportVariable(const std::string &VarName);
104  void genInitBoolExportVariable(const std::string &VarName,
105                                 const clang::APValue &Val);
106  void genInitPrimitiveExportVariable(const std::string &VarName,
107                                      const clang::APValue &Val);
108
109  // Produce an argument string of the form "T1 t, T2 u, T3 v".
110  void genArguments(const ArgumentList &Args, int Offset);
111
112  void genPointerTypeExportVariable(const RSExportVar *EV);
113  void genMatrixTypeExportVariable(const RSExportVar *EV);
114  void genRecordTypeExportVariable(const RSExportVar *EV);
115
116  void genGetterAndSetter(const RSExportPrimitiveType *EPT, const RSExportVar* EV);
117  void genGetterAndSetter(const RSExportVectorType *EVT, const RSExportVar* EV);
118  void genGetterAndSetter(const RSExportConstantArrayType *AT, const RSExportVar* EV);
119  void genGetterAndSetter(const RSExportRecordType *ERT, const RSExportVar *EV);
120
121  // Write out a local FieldPacker (if necessary).
122  bool genCreateFieldPacker(const RSExportType *T, const char *FieldPackerName);
123
124  // Populate (write) the FieldPacker with add() operations.
125  void genPackVarOfType(const RSExportType *ET, const char *VarName,
126                        const char *FieldPackerName);
127
128  // Generate a runtime type check for VarName.
129  void genTypeCheck(const RSExportType *ET, const char *VarName);
130
131  // Generate a type instance for a given forEach argument type.
132  void genTypeInstanceFromPointer(const RSExportType *ET);
133  void genTypeInstance(const RSExportType *ET);
134
135}; // class RSReflectionCpp
136
137} // namespace slang
138
139#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_REFLECTION_CPP_H_  NOLINT
140