| /* |
| * Copyright 2013, The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <sys/stat.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| #include <cstdarg> |
| #include <cctype> |
| |
| #include <algorithm> |
| #include <sstream> |
| #include <string> |
| #include <utility> |
| |
| #include "os_sep.h" |
| #include "slang_rs_context.h" |
| #include "slang_rs_export_var.h" |
| #include "slang_rs_export_foreach.h" |
| #include "slang_rs_export_func.h" |
| #include "slang_rs_reflect_utils.h" |
| #include "slang_version.h" |
| #include "slang_utils.h" |
| |
| #include "slang_rs_reflection_cpp.h" |
| |
| using namespace std; |
| |
| namespace slang { |
| |
| #define RS_TYPE_ITEM_CLASS_NAME "Item" |
| |
| #define RS_ELEM_PREFIX "__rs_elem_" |
| |
| static const char *GetMatrixTypeName(const RSExportMatrixType *EMT) { |
| static const char *MatrixTypeCNameMap[] = { |
| "rs_matrix2x2", |
| "rs_matrix3x3", |
| "rs_matrix4x4", |
| }; |
| unsigned Dim = EMT->getDim(); |
| |
| if ((Dim - 2) < (sizeof(MatrixTypeCNameMap) / sizeof(const char*))) |
| return MatrixTypeCNameMap[ EMT->getDim() - 2 ]; |
| |
| slangAssert(false && "GetMatrixTypeName : Unsupported matrix dimension"); |
| return NULL; |
| } |
| |
| |
| static std::string GetTypeName(const RSExportType *ET, bool Brackets = true) { |
| switch (ET->getClass()) { |
| case RSExportType::ExportClassPrimitive: { |
| const RSExportPrimitiveType *EPT = |
| static_cast<const RSExportPrimitiveType*>(ET); |
| if (EPT->isRSObjectType()) { |
| return std::string("android::RSC::sp<const android::RSC::") + |
| RSExportPrimitiveType::getRSReflectionType(EPT)->c_name + ">"; |
| } else { |
| return RSExportPrimitiveType::getRSReflectionType(EPT)->c_name; |
| } |
| } |
| case RSExportType::ExportClassPointer: { |
| const RSExportType *PointeeType = |
| static_cast<const RSExportPointerType*>(ET)->getPointeeType(); |
| |
| if (PointeeType->getClass() != RSExportType::ExportClassRecord) |
| return "android::RSC::sp<android::RSC::Allocation>"; |
| else |
| return PointeeType->getElementName(); |
| } |
| case RSExportType::ExportClassVector: { |
| const RSExportVectorType *EVT = |
| static_cast<const RSExportVectorType*>(ET); |
| std::stringstream VecName; |
| VecName << EVT->getRSReflectionType(EVT)->rs_c_vector_prefix |
| << EVT->getNumElement(); |
| return VecName.str(); |
| } |
| case RSExportType::ExportClassMatrix: { |
| return GetMatrixTypeName(static_cast<const RSExportMatrixType*>(ET)); |
| } |
| case RSExportType::ExportClassConstantArray: { |
| // TODO: Fix this for C arrays! |
| const RSExportConstantArrayType* CAT = |
| static_cast<const RSExportConstantArrayType*>(ET); |
| std::string ElementTypeName = GetTypeName(CAT->getElementType()); |
| if (Brackets) { |
| ElementTypeName.append("[]"); |
| } |
| return ElementTypeName; |
| } |
| case RSExportType::ExportClassRecord: { |
| // TODO: Fix for C structs! |
| return ET->getElementName() + "." RS_TYPE_ITEM_CLASS_NAME; |
| } |
| default: { |
| slangAssert(false && "Unknown class of type"); |
| } |
| } |
| |
| return ""; |
| } |
| |
| |
| RSReflectionCpp::RSReflectionCpp(const RSContext *con) |
| : RSReflectionBase(con) { |
| clear(); |
| } |
| |
| RSReflectionCpp::~RSReflectionCpp() { |
| } |
| |
| bool RSReflectionCpp::reflect(const string &OutputPathBase, |
| const string &InputFileName, |
| const string &OutputBCFileName) { |
| mInputFileName = InputFileName; |
| mOutputPath = OutputPathBase + OS_PATH_SEPARATOR_STR; |
| mOutputBCFileName = OutputBCFileName; |
| mClassName = string("ScriptC_") + stripRS(InputFileName); |
| |
| std::string Path = |
| RSSlangReflectUtils::ComputePackagedPath(OutputPathBase.c_str(), ""); |
| |
| std::string ErrorMsg; |
| if (!SlangUtils::CreateDirectoryWithParents(Path, &ErrorMsg)) { |
| fprintf(stderr, "Error: Could not create path %s - %s\n", |
| Path.c_str(), ErrorMsg.c_str()); |
| return false; |
| } |
| |
| makeHeader("android::RSC::ScriptC"); |
| std::vector< std::string > header(mText); |
| mText.clear(); |
| |
| makeImpl("android::RSC::ScriptC"); |
| std::vector< std::string > cpp(mText); |
| mText.clear(); |
| |
| |
| writeFile(mClassName + ".h", header); |
| writeFile(mClassName + ".cpp", cpp); |
| |
| |
| return true; |
| } |
| |
| |
| #define RS_TYPE_CLASS_NAME_PREFIX "ScriptField_" |
| |
| |
| |
| bool RSReflectionCpp::makeHeader(const std::string &baseClass) { |
| startFile(mClassName + ".h"); |
| |
| write(""); |
| write("#include \"RenderScript.h\""); |
| write("using namespace android::RSC;"); |
| write(""); |
| |
| // Imports |
| //for(unsigned i = 0; i < (sizeof(Import) / sizeof(const char*)); i++) |
| //out() << "import " << Import[i] << ";" << std::endl; |
| //out() << std::endl; |
| |
| if (!baseClass.empty()) { |
| write("class " + mClassName + " : public " + baseClass + " {"); |
| } else { |
| write("class " + mClassName + " {"); |
| } |
| |
| write("private:"); |
| uint32_t slot = 0; |
| incIndent(); |
| for (RSContext::const_export_var_iterator I = mRSContext->export_vars_begin(), |
| E = mRSContext->export_vars_end(); I != E; I++, slot++) { |
| const RSExportVar *ev = *I; |
| if (!ev->isConst()) { |
| write(GetTypeName(ev->getType()) + " " RS_EXPORT_VAR_PREFIX |
| + ev->getName() + ";"); |
| } |
| } |
| |
| for (RSContext::const_export_foreach_iterator |
| I = mRSContext->export_foreach_begin(), |
| E = mRSContext->export_foreach_end(); I != E; I++) { |
| const RSExportForEach *EF = *I; |
| const RSExportType *IET = EF->getInType(); |
| const RSExportType *OET = EF->getOutType(); |
| if (IET) { |
| genTypeInstanceFromPointer(IET); |
| } |
| if (OET) { |
| genTypeInstanceFromPointer(OET); |
| } |
| } |
| |
| for (std::set<std::string>::iterator I = mTypesToCheck.begin(), |
| E = mTypesToCheck.end(); |
| I != E; |
| I++) { |
| write("android::RSC::sp<const android::RSC::Element> " RS_ELEM_PREFIX |
| + *I + ";"); |
| } |
| |
| decIndent(); |
| |
| write("public:"); |
| incIndent(); |
| write(mClassName + "(android::RSC::sp<android::RSC::RS> rs);"); |
| write("virtual ~" + mClassName + "();"); |
| write(""); |
| |
| |
| // Reflect export variable |
| slot = 0; |
| for (RSContext::const_export_var_iterator I = mRSContext->export_vars_begin(), |
| E = mRSContext->export_vars_end(); I != E; I++, slot++) { |
| genExportVariable(*I); |
| } |
| |
| // Reflect export for each functions |
| for (RSContext::const_export_foreach_iterator |
| I = mRSContext->export_foreach_begin(), |
| E = mRSContext->export_foreach_end(); I != E; I++) { |
| const RSExportForEach *ef = *I; |
| if (ef->isDummyRoot()) { |
| write("// No forEach_root(...)"); |
| continue; |
| } |
| |
| ArgTy Args; |
| stringstream ss; |
| ss << "void forEach_" << ef->getName() << "("; |
| |
| if (ef->hasIn()) { |
| Args.push_back(std::make_pair( |
| "android::RSC::sp<const android::RSC::Allocation>", "ain")); |
| } |
| |
| if (ef->hasOut() || ef->hasReturn()) { |
| Args.push_back(std::make_pair( |
| "android::RSC::sp<const android::RSC::Allocation>", "aout")); |
| } |
| |
| const RSExportRecordType *ERT = ef->getParamPacketType(); |
| if (ERT) { |
| for (RSExportForEach::const_param_iterator i = ef->params_begin(), |
| e = ef->params_end(); i != e; i++) { |
| RSReflectionTypeData rtd; |
| (*i)->getType()->convertToRTD(&rtd); |
| Args.push_back(std::make_pair(rtd.type->c_name, (*i)->getName())); |
| } |
| } |
| makeArgs(ss, Args); |
| ss << ");"; |
| write(ss); |
| } |
| |
| |
| // Reflect export function |
| for (RSContext::const_export_func_iterator |
| I = mRSContext->export_funcs_begin(), |
| E = mRSContext->export_funcs_end(); I != E; I++) { |
| const RSExportFunc *ef = *I; |
| |
| stringstream ss; |
| makeFunctionSignature(ss, false, ef); |
| write(ss); |
| } |
| |
| decIndent(); |
| write("};"); |
| return true; |
| } |
| |
| bool RSReflectionCpp::writeBC() { |
| FILE *pfin = fopen(mOutputBCFileName.c_str(), "rb"); |
| if (pfin == NULL) { |
| fprintf(stderr, "Error: could not read file %s\n", |
| mOutputBCFileName.c_str()); |
| return false; |
| } |
| |
| unsigned char buf[16]; |
| int read_length; |
| write("static const unsigned char __txt[] = {"); |
| incIndent(); |
| while ((read_length = fread(buf, 1, sizeof(buf), pfin)) > 0) { |
| string s; |
| for (int i = 0; i < read_length; i++) { |
| char buf2[16]; |
| snprintf(buf2, sizeof(buf2), "0x%02x,", buf[i]); |
| s += buf2; |
| } |
| write(s); |
| } |
| decIndent(); |
| write("};"); |
| write(""); |
| return true; |
| } |
| |
| bool RSReflectionCpp::makeImpl(const std::string &baseClass) { |
| startFile(mClassName + ".cpp"); |
| |
| write(""); |
| write("#include \"" + mClassName + ".h\""); |
| write(""); |
| |
| writeBC(); |
| |
| // Imports |
| //for(unsigned i = 0; i < (sizeof(Import) / sizeof(const char*)); i++) |
| //out() << "import " << Import[i] << ";" << std::endl; |
| //out() << std::endl; |
| |
| write("\n"); |
| stringstream ss; |
| const std::string &packageName = mRSContext->getReflectJavaPackageName(); |
| ss << mClassName << "::" << mClassName |
| << "(android::RSC::sp<android::RSC::RS> rs):\n" |
| " ScriptC(rs, __txt, sizeof(__txt), \"" |
| << stripRS(mInputFileName) << "\", " << stripRS(mInputFileName).length() |
| << ", \"/data/data/" << packageName << "/app\", sizeof(\"" << packageName << "\")) {"; |
| write(ss); |
| ss.str(""); |
| incIndent(); |
| for (std::set<std::string>::iterator I = mTypesToCheck.begin(), |
| E = mTypesToCheck.end(); |
| I != E; |
| I++) { |
| write(RS_ELEM_PREFIX + *I + " = android::RSC::Element::" + *I + "(mRS);"); |
| } |
| |
| for (RSContext::const_export_var_iterator I = mRSContext->export_vars_begin(), |
| E = mRSContext->export_vars_end(); |
| I != E; |
| I++) { |
| const RSExportVar *EV = *I; |
| if (!EV->getInit().isUninit()) { |
| genInitExportVariable(EV->getType(), EV->getName(), EV->getInit()); |
| } else { |
| genZeroInitExportVariable(EV->getName()); |
| } |
| } |
| decIndent(); |
| write("}"); |
| write(""); |
| |
| write(mClassName + "::~" + mClassName + "() {"); |
| write("}"); |
| write(""); |
| |
| // Reflect export for each functions |
| uint32_t slot = 0; |
| for (RSContext::const_export_foreach_iterator |
| I = mRSContext->export_foreach_begin(), |
| E = mRSContext->export_foreach_end(); I != E; I++, slot++) { |
| const RSExportForEach *ef = *I; |
| if (ef->isDummyRoot()) { |
| write("// No forEach_root(...)"); |
| continue; |
| } |
| |
| stringstream tmp; |
| ArgTy Args; |
| tmp << "void " << mClassName << "::forEach_" << ef->getName() << "("; |
| |
| if (ef->hasIn()) { |
| Args.push_back(std::make_pair( |
| "android::RSC::sp<const android::RSC::Allocation>", "ain")); |
| } |
| |
| if (ef->hasOut() || ef->hasReturn()) { |
| Args.push_back(std::make_pair( |
| "android::RSC::sp<const android::RSC::Allocation>", "aout")); |
| } |
| |
| const RSExportRecordType *ERT = ef->getParamPacketType(); |
| if (ERT) { |
| for (RSExportForEach::const_param_iterator i = ef->params_begin(), |
| e = ef->params_end(); i != e; i++) { |
| RSReflectionTypeData rtd; |
| (*i)->getType()->convertToRTD(&rtd); |
| Args.push_back(std::make_pair(rtd.type->c_name, (*i)->getName())); |
| } |
| } |
| makeArgs(tmp, Args); |
| |
| tmp << ") {"; |
| write(tmp); |
| tmp.str(""); |
| |
| const RSExportType *IET = ef->getInType(); |
| const RSExportType *OET = ef->getOutType(); |
| |
| incIndent(); |
| if (IET) { |
| genTypeCheck(IET, "ain"); |
| } |
| |
| if (OET) { |
| genTypeCheck(OET, "aout"); |
| } |
| decIndent(); |
| |
| std::string FieldPackerName = ef->getName() + "_fp"; |
| if (ERT) { |
| if (genCreateFieldPacker(ERT, FieldPackerName.c_str())) { |
| genPackVarOfType(ERT, NULL, FieldPackerName.c_str()); |
| } |
| } |
| tmp << " forEach(" << slot << ", "; |
| |
| if (ef->hasIn()) { |
| tmp << "ain, "; |
| } else { |
| tmp << "NULL, "; |
| } |
| |
| if (ef->hasOut() || ef->hasReturn()) { |
| tmp << "aout, "; |
| } else { |
| tmp << "NULL, "; |
| } |
| |
| // FIXME (no support for usrData with C++ kernels) |
| tmp << "NULL, 0);"; |
| write(tmp); |
| |
| write("}"); |
| write(""); |
| } |
| |
| slot = 0; |
| // Reflect export function |
| for (RSContext::const_export_func_iterator |
| I = mRSContext->export_funcs_begin(), |
| E = mRSContext->export_funcs_end(); I != E; I++) { |
| const RSExportFunc *ef = *I; |
| |
| stringstream ss; |
| makeFunctionSignature(ss, true, ef); |
| write(ss); |
| ss.str(""); |
| const RSExportRecordType *params = ef->getParamPacketType(); |
| size_t param_len = 0; |
| if (params) { |
| param_len = RSExportType::GetTypeAllocSize(params); |
| if (genCreateFieldPacker(params, "__fp")) { |
| genPackVarOfType(params, NULL, "__fp"); |
| } |
| } |
| |
| ss.str(""); |
| ss << " invoke(" << slot; |
| if (params) { |
| ss << ", __fp.getData(), " << param_len << ");"; |
| } else { |
| ss << ", NULL, 0);"; |
| } |
| write(ss); |
| |
| write("}"); |
| write(""); |
| |
| slot++; |
| } |
| |
| decIndent(); |
| return true; |
| } |
| |
| void RSReflectionCpp::genExportVariable(const RSExportVar *EV) { |
| const RSExportType *ET = EV->getType(); |
| |
| switch (ET->getClass()) { |
| case RSExportType::ExportClassPrimitive: { |
| genPrimitiveTypeExportVariable(EV); |
| break; |
| } |
| case RSExportType::ExportClassPointer: { |
| genPointerTypeExportVariable(EV); |
| break; |
| } |
| case RSExportType::ExportClassVector: { |
| genVectorTypeExportVariable(EV); |
| break; |
| } |
| case RSExportType::ExportClassMatrix: { |
| genMatrixTypeExportVariable(EV); |
| break; |
| } |
| case RSExportType::ExportClassConstantArray: { |
| genConstantArrayTypeExportVariable(EV); |
| break; |
| } |
| case RSExportType::ExportClassRecord: { |
| genRecordTypeExportVariable(EV); |
| break; |
| } |
| default: { |
| slangAssert(false && "Unknown class of type"); |
| } |
| } |
| } |
| |
| |
| void RSReflectionCpp::genPrimitiveTypeExportVariable(const RSExportVar *EV) { |
| RSReflectionTypeData rtd; |
| const RSExportPrimitiveType *EPT = |
| static_cast<const RSExportPrimitiveType *>(EV->getType()); |
| EPT->convertToRTD(&rtd); |
| std::string TypeName = GetTypeName(EPT, false); |
| |
| if (!EV->isConst()) { |
| write(string("void set_") + EV->getName() + "(" + TypeName.c_str() + |
| " v) {"); |
| stringstream tmp; |
| tmp << getNextExportVarSlot() << ", "; |
| if (EPT->isRSObjectType()) { |
| tmp << "v);"; |
| } else { |
| tmp << "&v, sizeof(v));"; |
| } |
| write(string(" setVar(") + tmp.str()); |
| write(string(" " RS_EXPORT_VAR_PREFIX) + EV->getName() + " = v;"); |
| write("}"); |
| } |
| write(TypeName + " get_" + EV->getName() + "() const {"); |
| if (EV->isConst()) { |
| const clang::APValue &val = EV->getInit(); |
| bool isBool = !strcmp(TypeName.c_str(), "bool"); |
| write(string(" return ") + genInitValue(val, isBool) + ";"); |
| } else { |
| write(string(" return " RS_EXPORT_VAR_PREFIX) + EV->getName() + ";"); |
| } |
| write("}"); |
| write(""); |
| } |
| |
| void RSReflectionCpp::genPointerTypeExportVariable(const RSExportVar *EV) { |
| const RSExportType *ET = EV->getType(); |
| |
| slangAssert((ET->getClass() == RSExportType::ExportClassPointer) && |
| "Variable should be type of pointer here"); |
| |
| std::string TypeName = GetTypeName(ET); |
| std::string VarName = EV->getName(); |
| |
| RSReflectionTypeData rtd; |
| EV->getType()->convertToRTD(&rtd); |
| uint32_t slot = getNextExportVarSlot(); |
| |
| if (!EV->isConst()) { |
| write(string("void bind_") + VarName + "(" + TypeName + |
| " v) {"); |
| stringstream tmp; |
| tmp << slot; |
| write(string(" bindAllocation(v, ") + tmp.str() + ");"); |
| write(string(" " RS_EXPORT_VAR_PREFIX) + VarName + " = v;"); |
| write("}"); |
| } |
| write(TypeName + " get_" + VarName + "() const {"); |
| if (EV->isConst()) { |
| const clang::APValue &val = EV->getInit(); |
| bool isBool = !strcmp(TypeName.c_str(), "bool"); |
| write(string(" return ") + genInitValue(val, isBool) + ";"); |
| } else { |
| write(string(" return " RS_EXPORT_VAR_PREFIX) + VarName + ";"); |
| } |
| write("}"); |
| write(""); |
| |
| } |
| |
| void RSReflectionCpp::genVectorTypeExportVariable(const RSExportVar *EV) { |
| slangAssert((EV->getType()->getClass() == RSExportType::ExportClassVector) && |
| "Variable should be type of vector here"); |
| |
| const RSExportVectorType *EVT = |
| static_cast<const RSExportVectorType*>(EV->getType()); |
| slangAssert(EVT != NULL); |
| |
| RSReflectionTypeData rtd; |
| EVT->convertToRTD(&rtd); |
| |
| std::stringstream ss; |
| |
| if (!EV->isConst()) { |
| ss << "void set_" << EV->getName() << "(" << rtd.type->rs_c_vector_prefix |
| << EVT->getNumElement() << " v) {"; |
| write(ss); |
| ss.str(""); |
| ss << getNextExportVarSlot(); |
| write(string(" setVar(") + ss.str() + ", &v, sizeof(v));"); |
| ss.str(""); |
| write(string(" " RS_EXPORT_VAR_PREFIX) + EV->getName() + " = v;"); |
| write("}"); |
| } |
| ss << rtd.type->rs_c_vector_prefix << EVT->getNumElement() << " get_" |
| << EV->getName() << "() const {"; |
| write(ss); |
| ss.str(""); |
| if (EV->isConst()) { |
| const clang::APValue &val = EV->getInit(); |
| write(string(" return ") + genInitValue(val, false) + ";"); |
| } else { |
| write(string(" return " RS_EXPORT_VAR_PREFIX) + EV->getName() + ";"); |
| } |
| write("}"); |
| write(""); |
| } |
| |
| void RSReflectionCpp::genMatrixTypeExportVariable(const RSExportVar *EV) { |
| slangAssert(false); |
| } |
| |
| void RSReflectionCpp::genConstantArrayTypeExportVariable( |
| const RSExportVar *EV) { |
| slangAssert(false); |
| } |
| |
| void RSReflectionCpp::genRecordTypeExportVariable(const RSExportVar *EV) { |
| slangAssert(false); |
| } |
| |
| |
| void RSReflectionCpp::makeFunctionSignature( |
| std::stringstream &ss, |
| bool isDefinition, |
| const RSExportFunc *ef) { |
| ss << "void "; |
| if (isDefinition) { |
| ss << mClassName << "::"; |
| } |
| ss << "invoke_" << ef->getName() << "("; |
| |
| if (ef->getParamPacketType()) { |
| bool FirstArg = true; |
| for (RSExportFunc::const_param_iterator i = ef->params_begin(), |
| e = ef->params_end(); i != e; i++) { |
| RSReflectionTypeData rtd; |
| (*i)->getType()->convertToRTD(&rtd); |
| if (!FirstArg) { |
| ss << ", "; |
| } else { |
| FirstArg = false; |
| } |
| ss << rtd.type->c_name << " " << (*i)->getName(); |
| } |
| } |
| |
| if (isDefinition) { |
| ss << ") {"; |
| } else { |
| ss << ");"; |
| } |
| } |
| |
| void RSReflectionCpp::makeArgs(std::stringstream &ss, const ArgTy& Args) { |
| bool FirstArg = true; |
| |
| for (ArgTy::const_iterator I = Args.begin(), E = Args.end(); I != E; I++) { |
| if (!FirstArg) { |
| ss << ", "; |
| } else { |
| FirstArg = false; |
| } |
| |
| ss << I->first << " " << I->second; |
| } |
| } |
| |
| bool RSReflectionCpp::genCreateFieldPacker(const RSExportType *ET, |
| const char *FieldPackerName) { |
| size_t AllocSize = RSExportType::GetTypeAllocSize(ET); |
| |
| if (AllocSize > 0) { |
| std::stringstream ss; |
| ss << " FieldPacker " << FieldPackerName << "(" |
| << AllocSize << ");"; |
| write(ss); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| void RSReflectionCpp::genPackVarOfType(const RSExportType *ET, |
| const char *VarName, |
| const char *FieldPackerName) { |
| std::stringstream ss; |
| switch (ET->getClass()) { |
| case RSExportType::ExportClassPrimitive: |
| case RSExportType::ExportClassVector: |
| case RSExportType::ExportClassPointer: |
| case RSExportType::ExportClassMatrix: { |
| ss << " " << FieldPackerName << ".add(" << VarName << ");"; |
| write(ss); |
| break; |
| } |
| case RSExportType::ExportClassConstantArray: { |
| /*const RSExportConstantArrayType *ECAT = |
| static_cast<const RSExportConstantArrayType *>(ET); |
| |
| // TODO(zonr): more elegant way. Currently, we obtain the unique index |
| // variable (this method involves recursive call which means |
| // we may have more than one level loop, therefore we can't |
| // always use the same index variable name here) name given |
| // in the for-loop from counting the '.' in @VarName. |
| unsigned Level = 0; |
| size_t LastDotPos = 0; |
| std::string ElementVarName(VarName); |
| |
| while (LastDotPos != std::string::npos) { |
| LastDotPos = ElementVarName.find_first_of('.', LastDotPos + 1); |
| Level++; |
| } |
| std::string IndexVarName("ct"); |
| IndexVarName.append(llvm::utostr_32(Level)); |
| |
| C.indent() << "for (int " << IndexVarName << " = 0; " << |
| IndexVarName << " < " << ECAT->getSize() << "; " << |
| IndexVarName << "++)"; |
| C.startBlock(); |
| |
| ElementVarName.append("[" + IndexVarName + "]"); |
| genPackVarOfType(C, ECAT->getElementType(), ElementVarName.c_str(), |
| FieldPackerName); |
| |
| C.endBlock();*/ |
| break; |
| } |
| case RSExportType::ExportClassRecord: { |
| const RSExportRecordType *ERT = |
| static_cast<const RSExportRecordType*>(ET); |
| // Relative pos from now on in field packer |
| unsigned Pos = 0; |
| |
| for (RSExportRecordType::const_field_iterator I = ERT->fields_begin(), |
| E = ERT->fields_end(); |
| I != E; |
| I++) { |
| const RSExportRecordType::Field *F = *I; |
| std::string FieldName; |
| size_t FieldOffset = F->getOffsetInParent(); |
| size_t FieldStoreSize = RSExportType::GetTypeStoreSize(F->getType()); |
| size_t FieldAllocSize = RSExportType::GetTypeAllocSize(F->getType()); |
| |
| if (VarName != NULL) |
| FieldName = VarName + ("." + F->getName()); |
| else |
| FieldName = F->getName(); |
| |
| if (FieldOffset > Pos) { |
| ss.str(""); |
| ss << " " << FieldPackerName << ".skip(" |
| << (FieldOffset - Pos) << ");"; |
| write(ss); |
| } |
| |
| genPackVarOfType(F->getType(), FieldName.c_str(), FieldPackerName); |
| |
| // There is padding in the field type |
| if (FieldAllocSize > FieldStoreSize) { |
| ss.str(""); |
| ss << " " << FieldPackerName << ".skip(" |
| << (FieldAllocSize - FieldStoreSize) << ");"; |
| write(ss); |
| } |
| |
| Pos = FieldOffset + FieldAllocSize; |
| } |
| |
| // There maybe some padding after the struct |
| if (RSExportType::GetTypeAllocSize(ERT) > Pos) { |
| ss.str(""); |
| ss << " " << FieldPackerName << ".skip(" |
| << RSExportType::GetTypeAllocSize(ERT) - Pos << ");"; |
| write(ss); |
| } |
| break; |
| } |
| default: { |
| slangAssert(false && "Unknown class of type"); |
| } |
| } |
| } |
| |
| |
| void RSReflectionCpp::genTypeCheck(const RSExportType *ET, |
| const char *VarName) { |
| stringstream tmp; |
| tmp << "// Type check for " << VarName; |
| write(tmp); |
| tmp.str(""); |
| |
| if (ET->getClass() == RSExportType::ExportClassPointer) { |
| const RSExportPointerType *EPT = |
| static_cast<const RSExportPointerType*>(ET); |
| ET = EPT->getPointeeType(); |
| } |
| |
| std::string TypeName; |
| switch (ET->getClass()) { |
| case RSExportType::ExportClassPrimitive: |
| case RSExportType::ExportClassVector: |
| case RSExportType::ExportClassRecord: { |
| TypeName = ET->getElementName(); |
| break; |
| } |
| |
| default: |
| break; |
| } |
| |
| if (!TypeName.empty()) { |
| //tmp << "// TypeName: " << TypeName; |
| tmp << "if (!" << VarName |
| << "->getType()->getElement()->isCompatible(" |
| << RS_ELEM_PREFIX |
| << TypeName << ")) {"; |
| write(tmp); |
| |
| incIndent(); |
| write("mRS->throwError(RS_ERROR_RUNTIME_ERROR, " |
| "\"Incompatible type\");"); |
| write("return;"); |
| decIndent(); |
| |
| write("}"); |
| } |
| } |
| |
| void RSReflectionCpp::genTypeInstanceFromPointer(const RSExportType *ET) { |
| if (ET->getClass() == RSExportType::ExportClassPointer) { |
| // For pointer parameters to original forEach kernels. |
| const RSExportPointerType *EPT = |
| static_cast<const RSExportPointerType*>(ET); |
| genTypeInstance(EPT->getPointeeType()); |
| } else { |
| // For handling pass-by-value kernel parameters. |
| genTypeInstance(ET); |
| } |
| } |
| |
| void RSReflectionCpp::genTypeInstance(const RSExportType *ET) { |
| switch (ET->getClass()) { |
| case RSExportType::ExportClassPrimitive: |
| case RSExportType::ExportClassVector: |
| case RSExportType::ExportClassConstantArray: |
| case RSExportType::ExportClassRecord: { |
| std::string TypeName = ET->getElementName(); |
| addTypeNameForElement(TypeName); |
| break; |
| } |
| |
| default: |
| break; |
| } |
| } |
| |
| void RSReflectionCpp::genInitExportVariable(const RSExportType *ET, |
| const std::string &VarName, |
| const clang::APValue &Val) { |
| slangAssert(!Val.isUninit() && "Not a valid initializer"); |
| |
| switch (ET->getClass()) { |
| case RSExportType::ExportClassPrimitive: { |
| const RSExportPrimitiveType *EPT = |
| static_cast<const RSExportPrimitiveType*>(ET); |
| if (EPT->getType() == RSExportPrimitiveType::DataTypeBoolean) { |
| genInitBoolExportVariable(VarName, Val); |
| } else { |
| genInitPrimitiveExportVariable(VarName, Val); |
| } |
| break; |
| } |
| case RSExportType::ExportClassPointer: { |
| if (!Val.isInt() || Val.getInt().getSExtValue() != 0) |
| std::cerr << "Initializer which is non-NULL to pointer type variable " |
| "will be ignored" << std::endl; |
| break; |
| } |
| case RSExportType::ExportClassVector: { |
| const RSExportVectorType *EVT = |
| static_cast<const RSExportVectorType*>(ET); |
| switch (Val.getKind()) { |
| case clang::APValue::Int: |
| case clang::APValue::Float: { |
| for (unsigned i = 0; i < EVT->getNumElement(); i++) { |
| std::string Name = VarName + "." + getVectorAccessor(i); |
| genInitPrimitiveExportVariable(Name, Val); |
| } |
| break; |
| } |
| case clang::APValue::Vector: { |
| unsigned NumElements = |
| std::min(static_cast<unsigned>(EVT->getNumElement()), |
| Val.getVectorLength()); |
| for (unsigned i = 0; i < NumElements; i++) { |
| const clang::APValue &ElementVal = Val.getVectorElt(i); |
| std::string Name = VarName + "." + getVectorAccessor(i); |
| genInitPrimitiveExportVariable(Name, ElementVal); |
| } |
| break; |
| } |
| case clang::APValue::MemberPointer: |
| case clang::APValue::Uninitialized: |
| case clang::APValue::ComplexInt: |
| case clang::APValue::ComplexFloat: |
| case clang::APValue::LValue: |
| case clang::APValue::Array: |
| case clang::APValue::Struct: |
| case clang::APValue::Union: |
| case clang::APValue::AddrLabelDiff: { |
| slangAssert(false && "Unexpected type of value of initializer."); |
| } |
| } |
| break; |
| } |
| case RSExportType::ExportClassMatrix: |
| case RSExportType::ExportClassConstantArray: |
| case RSExportType::ExportClassRecord: { |
| slangAssert(false && "Unsupported initializer for record/matrix/constant " |
| "array type variable currently"); |
| break; |
| } |
| default: { |
| slangAssert(false && "Unknown class of type"); |
| } |
| } |
| return; |
| } |
| |
| void RSReflectionCpp::genZeroInitExportVariable(const std::string &VarName) { |
| std::stringstream ss; |
| ss << "memset(&" RS_EXPORT_VAR_PREFIX << VarName << ", 0, sizeof(" |
| << RS_EXPORT_VAR_PREFIX << VarName << "));"; |
| write(ss); |
| } |
| |
| void RSReflectionCpp::genInitPrimitiveExportVariable( |
| const std::string &VarName, |
| const clang::APValue &Val) { |
| slangAssert(!Val.isUninit() && "Not a valid initializer"); |
| |
| std::stringstream ss; |
| ss << RS_EXPORT_VAR_PREFIX << VarName << " = " |
| << RSReflectionBase::genInitValue(Val) << ";"; |
| write(ss); |
| } |
| |
| void RSReflectionCpp::genInitBoolExportVariable(const std::string &VarName, |
| const clang::APValue &Val) { |
| slangAssert(!Val.isUninit() && "Not a valid initializer"); |
| slangAssert((Val.getKind() == clang::APValue::Int) && |
| "Bool type has wrong initial APValue"); |
| |
| std::stringstream ss; |
| ss << RS_EXPORT_VAR_PREFIX << VarName << " = " |
| << ((Val.getInt().getSExtValue() == 0) ? "false" : "true") << ";"; |
| write(ss); |
| } |
| |
| } // namespace slang |