| /* |
| * Copyright 2010-2012, 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 "slang_rs_reflection.h" |
| |
| #include <sys/stat.h> |
| |
| #include <cstdarg> |
| #include <cctype> |
| |
| #include <algorithm> |
| #include <sstream> |
| #include <string> |
| #include <utility> |
| |
| #include "llvm/ADT/APFloat.h" |
| #include "llvm/ADT/StringExtras.h" |
| |
| #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_base.h" |
| |
| #define RS_SCRIPT_CLASS_NAME_PREFIX "ScriptC_" |
| #define RS_SCRIPT_CLASS_SUPER_CLASS_NAME "ScriptC" |
| |
| #define RS_TYPE_CLASS_SUPER_CLASS_NAME "android.renderscript.Script.FieldBase" |
| |
| #define RS_TYPE_ITEM_CLASS_NAME "Item" |
| |
| #define RS_TYPE_ITEM_BUFFER_NAME "mItemArray" |
| #define RS_TYPE_ITEM_BUFFER_PACKER_NAME "mIOBuffer" |
| #define RS_TYPE_ELEMENT_REF_NAME "mElementCache" |
| |
| #define RS_EXPORT_VAR_INDEX_PREFIX "mExportVarIdx_" |
| #define RS_EXPORT_VAR_PREFIX "mExportVar_" |
| #define RS_EXPORT_VAR_ELEM_PREFIX "mExportVarElem_" |
| #define RS_EXPORT_VAR_DIM_PREFIX "mExportVarDim_" |
| #define RS_EXPORT_VAR_CONST_PREFIX "const_" |
| |
| #define RS_ELEM_PREFIX "__" |
| |
| #define RS_EXPORT_FUNC_INDEX_PREFIX "mExportFuncIdx_" |
| #define RS_EXPORT_FOREACH_INDEX_PREFIX "mExportForEachIdx_" |
| |
| #define RS_EXPORT_VAR_ALLOCATION_PREFIX "mAlloction_" |
| #define RS_EXPORT_VAR_DATA_STORAGE_PREFIX "mData_" |
| |
| namespace slang { |
| |
| // Some utility function using internal in RSReflection |
| static bool GetClassNameFromFileName(const std::string &FileName, |
| std::string &ClassName) { |
| ClassName.clear(); |
| |
| if (FileName.empty() || (FileName == "-")) |
| return true; |
| |
| ClassName = |
| RSSlangReflectUtils::JavaClassNameFromRSFileName(FileName.c_str()); |
| |
| return true; |
| } |
| |
| static const char *GetMatrixTypeName(const RSExportMatrixType *EMT) { |
| static const char *MatrixTypeJavaNameMap[] = { |
| /* 2x2 */ "Matrix2f", |
| /* 3x3 */ "Matrix3f", |
| /* 4x4 */ "Matrix4f", |
| }; |
| unsigned Dim = EMT->getDim(); |
| |
| if ((Dim - 2) < (sizeof(MatrixTypeJavaNameMap) / sizeof(const char*))) |
| return MatrixTypeJavaNameMap[ EMT->getDim() - 2 ]; |
| |
| slangAssert(false && "GetMatrixTypeName : Unsupported matrix dimension"); |
| return NULL; |
| } |
| |
| static const char *GetVectorAccessor(unsigned Index) { |
| static const char *VectorAccessorMap[] = { |
| /* 0 */ "x", |
| /* 1 */ "y", |
| /* 2 */ "z", |
| /* 3 */ "w", |
| }; |
| |
| slangAssert((Index < (sizeof(VectorAccessorMap) / sizeof(const char*))) && |
| "Out-of-bound index to access vector member"); |
| |
| return VectorAccessorMap[Index]; |
| } |
| |
| static const char *GetPackerAPIName(const RSExportPrimitiveType *EPT) { |
| static const char *PrimitiveTypePackerAPINameMap[] = { |
| "", // RSExportPrimitiveType::DataTypeFloat16 |
| "addF32", // RSExportPrimitiveType::DataTypeFloat32 |
| "addF64", // RSExportPrimitiveType::DataTypeFloat64 |
| "addI8", // RSExportPrimitiveType::DataTypeSigned8 |
| "addI16", // RSExportPrimitiveType::DataTypeSigned16 |
| "addI32", // RSExportPrimitiveType::DataTypeSigned32 |
| "addI64", // RSExportPrimitiveType::DataTypeSigned64 |
| "addU8", // RSExportPrimitiveType::DataTypeUnsigned8 |
| "addU16", // RSExportPrimitiveType::DataTypeUnsigned16 |
| "addU32", // RSExportPrimitiveType::DataTypeUnsigned32 |
| "addU64", // RSExportPrimitiveType::DataTypeUnsigned64 |
| "addBoolean", // RSExportPrimitiveType::DataTypeBoolean |
| |
| "addU16", // RSExportPrimitiveType::DataTypeUnsigned565 |
| "addU16", // RSExportPrimitiveType::DataTypeUnsigned5551 |
| "addU16", // RSExportPrimitiveType::DataTypeUnsigned4444 |
| |
| "addMatrix", // RSExportPrimitiveType::DataTypeRSMatrix2x2 |
| "addMatrix", // RSExportPrimitiveType::DataTypeRSMatrix3x3 |
| "addMatrix", // RSExportPrimitiveType::DataTypeRSMatrix4x4 |
| |
| "addObj", // RSExportPrimitiveType::DataTypeRSElement |
| "addObj", // RSExportPrimitiveType::DataTypeRSType |
| "addObj", // RSExportPrimitiveType::DataTypeRSAllocation |
| "addObj", // RSExportPrimitiveType::DataTypeRSSampler |
| "addObj", // RSExportPrimitiveType::DataTypeRSScript |
| "addObj", // RSExportPrimitiveType::DataTypeRSMesh |
| "addObj", // RSExportPrimitiveType::DataTypeRSPath |
| "addObj", // RSExportPrimitiveType::DataTypeRSProgramFragment |
| "addObj", // RSExportPrimitiveType::DataTypeRSProgramVertex |
| "addObj", // RSExportPrimitiveType::DataTypeRSProgramRaster |
| "addObj", // RSExportPrimitiveType::DataTypeRSProgramStore |
| "addObj", // RSExportPrimitiveType::DataTypeRSFont |
| }; |
| unsigned TypeId = EPT->getType(); |
| |
| if (TypeId < (sizeof(PrimitiveTypePackerAPINameMap) / sizeof(const char*))) |
| return PrimitiveTypePackerAPINameMap[ EPT->getType() ]; |
| |
| slangAssert(false && "GetPackerAPIName : Unknown primitive data type"); |
| return NULL; |
| } |
| |
| static std::string GetTypeName(const RSExportType *ET, bool Brackets = true) { |
| switch (ET->getClass()) { |
| case RSExportType::ExportClassPrimitive: { |
| return RSExportPrimitiveType::getRSReflectionType( |
| static_cast<const RSExportPrimitiveType*>(ET))->java_name; |
| } |
| case RSExportType::ExportClassPointer: { |
| const RSExportType *PointeeType = |
| static_cast<const RSExportPointerType*>(ET)->getPointeeType(); |
| |
| if (PointeeType->getClass() != RSExportType::ExportClassRecord) |
| return "Allocation"; |
| else |
| return PointeeType->getElementName(); |
| } |
| case RSExportType::ExportClassVector: { |
| const RSExportVectorType *EVT = |
| static_cast<const RSExportVectorType*>(ET); |
| std::stringstream VecName; |
| VecName << EVT->getRSReflectionType(EVT)->rs_java_vector_prefix |
| << EVT->getNumElement(); |
| return VecName.str(); |
| } |
| case RSExportType::ExportClassMatrix: { |
| return GetMatrixTypeName(static_cast<const RSExportMatrixType*>(ET)); |
| } |
| case RSExportType::ExportClassConstantArray: { |
| const RSExportConstantArrayType* CAT = |
| static_cast<const RSExportConstantArrayType*>(ET); |
| std::string ElementTypeName = GetTypeName(CAT->getElementType()); |
| if (Brackets) { |
| ElementTypeName.append("[]"); |
| } |
| return ElementTypeName; |
| } |
| case RSExportType::ExportClassRecord: { |
| return ET->getElementName() + "."RS_TYPE_ITEM_CLASS_NAME; |
| } |
| default: { |
| slangAssert(false && "Unknown class of type"); |
| } |
| } |
| |
| return ""; |
| } |
| |
| static const char *GetTypeNullValue(const RSExportType *ET) { |
| switch (ET->getClass()) { |
| case RSExportType::ExportClassPrimitive: { |
| const RSExportPrimitiveType *EPT = |
| static_cast<const RSExportPrimitiveType*>(ET); |
| if (EPT->isRSObjectType()) |
| return "null"; |
| else if (EPT->getType() == RSExportPrimitiveType::DataTypeBoolean) |
| return "false"; |
| else |
| return "0"; |
| break; |
| } |
| case RSExportType::ExportClassPointer: |
| case RSExportType::ExportClassVector: |
| case RSExportType::ExportClassMatrix: |
| case RSExportType::ExportClassConstantArray: |
| case RSExportType::ExportClassRecord: { |
| return "null"; |
| break; |
| } |
| default: { |
| slangAssert(false && "Unknown class of type"); |
| } |
| } |
| return ""; |
| } |
| |
| static std::string GetBuiltinElementConstruct(const RSExportType *ET) { |
| if (ET->getClass() == RSExportType::ExportClassPrimitive) { |
| return std::string("Element.") + ET->getElementName(); |
| } else if (ET->getClass() == RSExportType::ExportClassVector) { |
| const RSExportVectorType *EVT = static_cast<const RSExportVectorType*>(ET); |
| if (EVT->getType() == RSExportPrimitiveType::DataTypeFloat32) { |
| if (EVT->getNumElement() == 2) |
| return "Element.F32_2"; |
| else if (EVT->getNumElement() == 3) |
| return "Element.F32_3"; |
| else if (EVT->getNumElement() == 4) |
| return "Element.F32_4"; |
| } else if (EVT->getType() == RSExportPrimitiveType::DataTypeUnsigned8) { |
| if (EVT->getNumElement() == 4) |
| return "Element.U8_4"; |
| } |
| } else if (ET->getClass() == RSExportType::ExportClassMatrix) { |
| const RSExportMatrixType *EMT = static_cast<const RSExportMatrixType *>(ET); |
| switch (EMT->getDim()) { |
| case 2: return "Element.MATRIX_2X2"; |
| case 3: return "Element.MATRIX_3X3"; |
| case 4: return "Element.MATRIX_4X4"; |
| default: slangAssert(false && "Unsupported dimension of matrix"); |
| } |
| } |
| // RSExportType::ExportClassPointer can't be generated in a struct. |
| |
| return ""; |
| } |
| |
| |
| /********************** Methods to generate script class **********************/ |
| bool RSReflection::genScriptClass(Context &C, |
| const std::string &ClassName, |
| std::string &ErrorMsg) { |
| if (!C.startClass(Context::AM_Public, |
| false, |
| ClassName, |
| RS_SCRIPT_CLASS_SUPER_CLASS_NAME, |
| ErrorMsg)) |
| return false; |
| |
| genScriptClassConstructor(C); |
| |
| // Reflect export variable |
| for (RSContext::const_export_var_iterator I = mRSContext->export_vars_begin(), |
| E = mRSContext->export_vars_end(); |
| I != E; |
| I++) |
| genExportVariable(C, *I); |
| |
| // Reflect export for each functions (only available on ICS+) |
| if (mRSContext->getTargetAPI() >= SLANG_ICS_TARGET_API) { |
| for (RSContext::const_export_foreach_iterator |
| I = mRSContext->export_foreach_begin(), |
| E = mRSContext->export_foreach_end(); |
| I != E; I++) |
| genExportForEach(C, *I); |
| } |
| |
| // Reflect export function |
| for (RSContext::const_export_func_iterator |
| I = mRSContext->export_funcs_begin(), |
| E = mRSContext->export_funcs_end(); |
| I != E; I++) |
| genExportFunction(C, *I); |
| |
| C.endClass(); |
| |
| return true; |
| } |
| |
| void RSReflection::genScriptClassConstructor(Context &C) { |
| C.indent() << "// Constructor" << std::endl; |
| C.startFunction(Context::AM_Public, |
| false, |
| NULL, |
| C.getClassName(), |
| 3, |
| "RenderScript", "rs", |
| "Resources", "resources", |
| "int", "id"); |
| // Call constructor of super class |
| C.indent() << "super(rs, resources, id);" << std::endl; |
| |
| // If an exported variable has initial value, reflect it |
| |
| 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(C, EV->getType(), EV->getName(), EV->getInit()); |
| } else if (EV->getArraySize()) { |
| // Always create an initial zero-init array object. |
| C.indent() << RS_EXPORT_VAR_PREFIX << EV->getName() << " = new " |
| << GetTypeName(EV->getType(), false) << "[" |
| << EV->getArraySize() << "];" << std::endl; |
| size_t NumInits = EV->getNumInits(); |
| const RSExportConstantArrayType *ECAT = |
| static_cast<const RSExportConstantArrayType*>(EV->getType()); |
| const RSExportType *ET = ECAT->getElementType(); |
| for (size_t i = 0; i < NumInits; i++) { |
| std::stringstream Name; |
| Name << EV->getName() << "[" << i << "]"; |
| genInitExportVariable(C, ET, Name.str(), EV->getInitArray(i)); |
| } |
| } |
| if (mRSContext->getTargetAPI() >= SLANG_JB_TARGET_API) { |
| genTypeInstance(C, EV->getType()); |
| } |
| } |
| |
| 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(); |
| if (IET) { |
| genTypeInstanceFromPointer(C, IET); |
| } |
| const RSExportType *OET = EF->getOutType(); |
| if (OET) { |
| genTypeInstanceFromPointer(C, OET); |
| } |
| } |
| |
| C.endFunction(); |
| |
| for (std::set<std::string>::iterator I = C.mTypesToCheck.begin(), |
| E = C.mTypesToCheck.end(); |
| I != E; |
| I++) { |
| C.indent() << "private Element " RS_ELEM_PREFIX << *I << ";" << std::endl; |
| } |
| |
| return; |
| } |
| |
| void RSReflection::genInitBoolExportVariable(Context &C, |
| const std::string &VarName, |
| const clang::APValue &Val) { |
| slangAssert(!Val.isUninit() && "Not a valid initializer"); |
| |
| C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = "; |
| slangAssert((Val.getKind() == clang::APValue::Int) && |
| "Bool type has wrong initial APValue"); |
| |
| C.out() << ((Val.getInt().getSExtValue() == 0) ? "false" : "true") |
| << ";" << std::endl; |
| |
| return; |
| } |
| |
| void RSReflection::genInitPrimitiveExportVariable( |
| Context &C, |
| const std::string &VarName, |
| const clang::APValue &Val) { |
| slangAssert(!Val.isUninit() && "Not a valid initializer"); |
| |
| C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = "; |
| C.out() << RSReflectionBase::genInitValue(Val); |
| C.out() << ";" << std::endl; |
| |
| return; |
| } |
| |
| void RSReflection::genInitExportVariable(Context &C, |
| 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(C, VarName, Val); |
| } else { |
| genInitPrimitiveExportVariable(C, VarName, Val); |
| } |
| break; |
| } |
| case RSExportType::ExportClassPointer: { |
| if (!Val.isInt() || Val.getInt().getSExtValue() != 0) |
| std::cout << "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(C, Name, Val); |
| } |
| break; |
| } |
| case clang::APValue::Vector: { |
| std::stringstream VecName; |
| VecName << EVT->getRSReflectionType(EVT)->rs_java_vector_prefix |
| << EVT->getNumElement(); |
| C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = new " |
| << VecName.str() << "();" << std::endl; |
| |
| 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(C, 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; |
| } |
| // TODO(zonr): Resolving initializer of a record (and matrix) type variable |
| // is complex. It cannot obtain by just simply evaluating the initializer |
| // expression. |
| case RSExportType::ExportClassMatrix: |
| case RSExportType::ExportClassConstantArray: |
| case RSExportType::ExportClassRecord: { |
| #if 0 |
| unsigned InitIndex = 0; |
| const RSExportRecordType *ERT = |
| static_cast<const RSExportRecordType*>(ET); |
| |
| slangAssert((Val.getKind() == clang::APValue::Vector) && |
| "Unexpected type of initializer for record type variable"); |
| |
| C.indent() << RS_EXPORT_VAR_PREFIX << VarName |
| << " = new " << ERT->getElementName() |
| << "."RS_TYPE_ITEM_CLASS_NAME"();" << std::endl; |
| |
| for (RSExportRecordType::const_field_iterator I = ERT->fields_begin(), |
| E = ERT->fields_end(); |
| I != E; |
| I++) { |
| const RSExportRecordType::Field *F = *I; |
| std::string FieldName = VarName + "." + F->getName(); |
| |
| if (InitIndex > Val.getVectorLength()) |
| break; |
| |
| genInitPrimitiveExportVariable(C, |
| FieldName, |
| Val.getVectorElt(InitIndex++)); |
| } |
| #endif |
| slangAssert(false && "Unsupported initializer for record/matrix/constant " |
| "array type variable currently"); |
| break; |
| } |
| default: { |
| slangAssert(false && "Unknown class of type"); |
| } |
| } |
| return; |
| } |
| |
| void RSReflection::genExportVariable(Context &C, const RSExportVar *EV) { |
| const RSExportType *ET = EV->getType(); |
| |
| C.indent() << "private final static int "RS_EXPORT_VAR_INDEX_PREFIX |
| << EV->getName() << " = " << C.getNextExportVarSlot() << ";" |
| << std::endl; |
| |
| switch (ET->getClass()) { |
| case RSExportType::ExportClassPrimitive: { |
| genPrimitiveTypeExportVariable(C, EV); |
| break; |
| } |
| case RSExportType::ExportClassPointer: { |
| genPointerTypeExportVariable(C, EV); |
| break; |
| } |
| case RSExportType::ExportClassVector: { |
| genVectorTypeExportVariable(C, EV); |
| break; |
| } |
| case RSExportType::ExportClassMatrix: { |
| genMatrixTypeExportVariable(C, EV); |
| break; |
| } |
| case RSExportType::ExportClassConstantArray: { |
| genConstantArrayTypeExportVariable(C, EV); |
| break; |
| } |
| case RSExportType::ExportClassRecord: { |
| genRecordTypeExportVariable(C, EV); |
| break; |
| } |
| default: { |
| slangAssert(false && "Unknown class of type"); |
| } |
| } |
| |
| return; |
| } |
| |
| void RSReflection::genExportFunction(Context &C, const RSExportFunc *EF) { |
| C.indent() << "private final static int "RS_EXPORT_FUNC_INDEX_PREFIX |
| << EF->getName() << " = " << C.getNextExportFuncSlot() << ";" |
| << std::endl; |
| |
| // invoke_*() |
| Context::ArgTy Args; |
| |
| if (EF->hasParam()) { |
| for (RSExportFunc::const_param_iterator I = EF->params_begin(), |
| E = EF->params_end(); |
| I != E; |
| I++) { |
| Args.push_back(std::make_pair(GetTypeName((*I)->getType()), |
| (*I)->getName())); |
| } |
| } |
| |
| C.startFunction(Context::AM_Public, |
| false, |
| "void", |
| "invoke_" + EF->getName(/*Mangle=*/ false), |
| // We are using un-mangled name since Java |
| // supports method overloading. |
| Args); |
| |
| if (!EF->hasParam()) { |
| C.indent() << "invoke("RS_EXPORT_FUNC_INDEX_PREFIX << EF->getName() << ");" |
| << std::endl; |
| } else { |
| const RSExportRecordType *ERT = EF->getParamPacketType(); |
| std::string FieldPackerName = EF->getName() + "_fp"; |
| |
| if (genCreateFieldPacker(C, ERT, FieldPackerName.c_str())) |
| genPackVarOfType(C, ERT, NULL, FieldPackerName.c_str()); |
| |
| C.indent() << "invoke("RS_EXPORT_FUNC_INDEX_PREFIX << EF->getName() << ", " |
| << FieldPackerName << ");" << std::endl; |
| } |
| |
| C.endFunction(); |
| return; |
| } |
| |
| void RSReflection::genExportForEach(Context &C, const RSExportForEach *EF) { |
| if (EF->isDummyRoot()) { |
| // Skip reflection for dummy root() kernels. Note that we have to |
| // advance the next slot number for ForEach, however. |
| C.indent() << "//private final static int "RS_EXPORT_FOREACH_INDEX_PREFIX |
| << EF->getName() << " = " << C.getNextExportForEachSlot() << ";" |
| << std::endl; |
| return; |
| } |
| |
| C.indent() << "private final static int "RS_EXPORT_FOREACH_INDEX_PREFIX |
| << EF->getName() << " = " << C.getNextExportForEachSlot() << ";" |
| << std::endl; |
| |
| // forEach_*() |
| Context::ArgTy Args; |
| |
| slangAssert(EF->getNumParameters() > 0); |
| |
| if (EF->hasIn()) |
| Args.push_back(std::make_pair("Allocation", "ain")); |
| if (EF->hasOut()) |
| Args.push_back(std::make_pair("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++) { |
| Args.push_back(std::make_pair(GetTypeName((*I)->getType()), |
| (*I)->getName())); |
| } |
| } |
| |
| C.startFunction(Context::AM_Public, |
| false, |
| "void", |
| "forEach_" + EF->getName(), |
| Args); |
| |
| const RSExportType *IET = EF->getInType(); |
| if (IET) { |
| genTypeCheck(C, IET, "ain"); |
| } |
| |
| const RSExportType *OET = EF->getOutType(); |
| if (OET) { |
| genTypeCheck(C, OET, "aout"); |
| } |
| |
| if (EF->hasIn() && EF->hasOut()) { |
| C.indent() << "// Verify dimensions" << std::endl; |
| C.indent() << "Type tIn = ain.getType();" << std::endl; |
| C.indent() << "Type tOut = aout.getType();" << std::endl; |
| C.indent() << "if ((tIn.getCount() != tOut.getCount()) ||" << std::endl; |
| C.indent() << " (tIn.getX() != tOut.getX()) ||" << std::endl; |
| C.indent() << " (tIn.getY() != tOut.getY()) ||" << std::endl; |
| C.indent() << " (tIn.getZ() != tOut.getZ()) ||" << std::endl; |
| C.indent() << " (tIn.hasFaces() != tOut.hasFaces()) ||" << std::endl; |
| C.indent() << " (tIn.hasMipmaps() != tOut.hasMipmaps())) {" << std::endl; |
| C.indent() << " throw new RSRuntimeException(\"Dimension mismatch " |
| << "between input and output parameters!\");"; |
| C.out() << std::endl; |
| C.indent() << "}" << std::endl; |
| } |
| |
| std::string FieldPackerName = EF->getName() + "_fp"; |
| if (ERT) { |
| if (genCreateFieldPacker(C, ERT, FieldPackerName.c_str())) { |
| genPackVarOfType(C, ERT, NULL, FieldPackerName.c_str()); |
| } |
| } |
| C.indent() << "forEach("RS_EXPORT_FOREACH_INDEX_PREFIX << EF->getName(); |
| |
| if (EF->hasIn()) |
| C.out() << ", ain"; |
| else |
| C.out() << ", null"; |
| |
| if (EF->hasOut()) |
| C.out() << ", aout"; |
| else |
| C.out() << ", null"; |
| |
| if (EF->hasUsrData()) |
| C.out() << ", " << FieldPackerName; |
| else |
| C.out() << ", null"; |
| |
| C.out() << ");" << std::endl; |
| |
| C.endFunction(); |
| return; |
| } |
| |
| void RSReflection::genTypeInstanceFromPointer(Context &C, |
| const RSExportType *ET) { |
| if (ET->getClass() == RSExportType::ExportClassPointer) { |
| const RSExportPointerType *EPT = |
| static_cast<const RSExportPointerType*>(ET); |
| genTypeInstance(C, EPT->getPointeeType()); |
| } |
| } |
| |
| void RSReflection::genTypeInstance(Context &C, |
| const RSExportType *ET) { |
| switch (ET->getClass()) { |
| case RSExportType::ExportClassPrimitive: |
| case RSExportType::ExportClassVector: |
| case RSExportType::ExportClassConstantArray: { |
| std::string TypeName = ET->getElementName(); |
| if (C.mTypesToCheck.find(TypeName) == C.mTypesToCheck.end()) { |
| C.indent() << RS_ELEM_PREFIX << TypeName << " = Element." << TypeName |
| << "(rs);" << std::endl; |
| C.mTypesToCheck.insert(TypeName); |
| } |
| break; |
| } |
| |
| case RSExportType::ExportClassRecord: { |
| std::string ClassName = ET->getElementName(); |
| if (C.mTypesToCheck.find(ClassName) == C.mTypesToCheck.end()) { |
| C.indent() << RS_ELEM_PREFIX << ClassName << " = " << ClassName << |
| ".createElement(rs);" << std::endl; |
| C.mTypesToCheck.insert(ClassName); |
| } |
| break; |
| } |
| |
| default: |
| break; |
| } |
| } |
| |
| void RSReflection::genTypeCheck(Context &C, |
| const RSExportType *ET, |
| const char *VarName) { |
| C.indent() << "// check " << VarName << std::endl; |
| |
| 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()) { |
| C.indent() << "if (!" << VarName |
| << ".getType().getElement().isCompatible(" RS_ELEM_PREFIX |
| << TypeName << ")) {" << std::endl; |
| C.indent() << " throw new RSRuntimeException(\"Type mismatch with " |
| << TypeName << "!\");" << std::endl; |
| C.indent() << "}" << std::endl; |
| } |
| |
| return; |
| } |
| |
| |
| void RSReflection::genPrimitiveTypeExportVariable( |
| Context &C, |
| const RSExportVar *EV) { |
| slangAssert((EV->getType()->getClass() == RSExportType::ExportClassPrimitive) |
| && "Variable should be type of primitive here"); |
| |
| const RSExportPrimitiveType *EPT = |
| static_cast<const RSExportPrimitiveType*>(EV->getType()); |
| std::string TypeName = GetTypeName(EPT); |
| std::string VarName = EV->getName(); |
| |
| genPrivateExportVariable(C, TypeName, EV->getName()); |
| |
| if (EV->isConst()) { |
| C.indent() << "public final static " << TypeName |
| << " " RS_EXPORT_VAR_CONST_PREFIX << VarName << " = "; |
| const clang::APValue &Val = EV->getInit(); |
| C.out() << RSReflectionBase::genInitValue(Val, EPT->getType() == |
| RSExportPrimitiveType::DataTypeBoolean) << ";" << std::endl; |
| } else { |
| // set_*() |
| C.startFunction(Context::AM_Public, |
| false, |
| "void", |
| "set_" + VarName, |
| 1, |
| TypeName.c_str(), "v"); |
| C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;" << std::endl; |
| |
| C.indent() << "setVar("RS_EXPORT_VAR_INDEX_PREFIX << VarName |
| << ", v);" << std::endl; |
| |
| C.endFunction(); |
| } |
| |
| genGetExportVariable(C, TypeName, VarName); |
| return; |
| } |
| |
| void RSReflection::genPointerTypeExportVariable(Context &C, |
| const RSExportVar *EV) { |
| const RSExportType *ET = EV->getType(); |
| const RSExportType *PointeeType; |
| |
| slangAssert((ET->getClass() == RSExportType::ExportClassPointer) && |
| "Variable should be type of pointer here"); |
| |
| PointeeType = static_cast<const RSExportPointerType*>(ET)->getPointeeType(); |
| std::string TypeName = GetTypeName(ET); |
| std::string VarName = EV->getName(); |
| |
| genPrivateExportVariable(C, TypeName, VarName); |
| |
| // bind_*() |
| C.startFunction(Context::AM_Public, |
| false, |
| "void", |
| "bind_" + VarName, |
| 1, |
| TypeName.c_str(), "v"); |
| |
| C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;" << std::endl; |
| C.indent() << "if (v == null) bindAllocation(null, "RS_EXPORT_VAR_INDEX_PREFIX |
| << VarName << ");" << std::endl; |
| |
| if (PointeeType->getClass() == RSExportType::ExportClassRecord) |
| C.indent() << "else bindAllocation(v.getAllocation(), " |
| RS_EXPORT_VAR_INDEX_PREFIX << VarName << ");" |
| << std::endl; |
| else |
| C.indent() << "else bindAllocation(v, "RS_EXPORT_VAR_INDEX_PREFIX |
| << VarName << ");" << std::endl; |
| |
| C.endFunction(); |
| |
| genGetExportVariable(C, TypeName, VarName); |
| return; |
| } |
| |
| void RSReflection::genVectorTypeExportVariable(Context &C, |
| const RSExportVar *EV) { |
| slangAssert((EV->getType()->getClass() == RSExportType::ExportClassVector) && |
| "Variable should be type of vector here"); |
| |
| std::string TypeName = GetTypeName(EV->getType()); |
| std::string VarName = EV->getName(); |
| |
| genPrivateExportVariable(C, TypeName, VarName); |
| genSetExportVariable(C, TypeName, EV); |
| genGetExportVariable(C, TypeName, VarName); |
| return; |
| } |
| |
| void RSReflection::genMatrixTypeExportVariable(Context &C, |
| const RSExportVar *EV) { |
| slangAssert((EV->getType()->getClass() == RSExportType::ExportClassMatrix) && |
| "Variable should be type of matrix here"); |
| |
| const RSExportType *ET = EV->getType(); |
| std::string TypeName = GetTypeName(ET); |
| std::string VarName = EV->getName(); |
| |
| genPrivateExportVariable(C, TypeName, VarName); |
| |
| // set_*() |
| if (!EV->isConst()) { |
| const char *FieldPackerName = "fp"; |
| C.startFunction(Context::AM_Public, |
| false, |
| "void", |
| "set_" + VarName, |
| 1, |
| TypeName.c_str(), "v"); |
| C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;" << std::endl; |
| |
| if (genCreateFieldPacker(C, ET, FieldPackerName)) |
| genPackVarOfType(C, ET, "v", FieldPackerName); |
| C.indent() << "setVar("RS_EXPORT_VAR_INDEX_PREFIX << VarName << ", " |
| << FieldPackerName << ");" << std::endl; |
| |
| C.endFunction(); |
| } |
| |
| genGetExportVariable(C, TypeName, VarName); |
| return; |
| } |
| |
| void RSReflection::genConstantArrayTypeExportVariable( |
| Context &C, |
| const RSExportVar *EV) { |
| slangAssert((EV->getType()->getClass() == |
| RSExportType::ExportClassConstantArray) && |
| "Variable should be type of constant array here"); |
| |
| std::string TypeName = GetTypeName(EV->getType()); |
| std::string VarName = EV->getName(); |
| |
| genPrivateExportVariable(C, TypeName, VarName); |
| genSetExportVariable(C, TypeName, EV); |
| genGetExportVariable(C, TypeName, VarName); |
| return; |
| } |
| |
| void RSReflection::genRecordTypeExportVariable(Context &C, |
| const RSExportVar *EV) { |
| slangAssert((EV->getType()->getClass() == RSExportType::ExportClassRecord) && |
| "Variable should be type of struct here"); |
| |
| std::string TypeName = GetTypeName(EV->getType()); |
| std::string VarName = EV->getName(); |
| |
| genPrivateExportVariable(C, TypeName, VarName); |
| genSetExportVariable(C, TypeName, EV); |
| genGetExportVariable(C, TypeName, VarName); |
| return; |
| } |
| |
| void RSReflection::genPrivateExportVariable(Context &C, |
| const std::string &TypeName, |
| const std::string &VarName) { |
| C.indent() << "private " << TypeName << " "RS_EXPORT_VAR_PREFIX |
| << VarName << ";" << std::endl; |
| return; |
| } |
| |
| void RSReflection::genSetExportVariable(Context &C, |
| const std::string &TypeName, |
| const RSExportVar *EV) { |
| if (!EV->isConst()) { |
| const char *FieldPackerName = "fp"; |
| std::string VarName = EV->getName(); |
| const RSExportType *ET = EV->getType(); |
| C.startFunction(Context::AM_Public, |
| false, |
| "void", |
| "set_" + VarName, |
| 1, |
| TypeName.c_str(), "v"); |
| C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;" << std::endl; |
| |
| if (genCreateFieldPacker(C, ET, FieldPackerName)) |
| genPackVarOfType(C, ET, "v", FieldPackerName); |
| |
| if (mRSContext->getTargetAPI() < SLANG_JB_TARGET_API) { |
| // Legacy apps must use the old setVar() without Element/dim components. |
| C.indent() << "setVar("RS_EXPORT_VAR_INDEX_PREFIX << VarName |
| << ", " << FieldPackerName << ");" << std::endl; |
| } else { |
| // We only have support for one-dimensional array reflection today, |
| // but the entry point (i.e. setVar()) takes an array of dimensions. |
| C.indent() << "int []__dimArr = new int[1];" << std::endl; |
| C.indent() << "__dimArr[0] = " << ET->getSize() << ";" << std::endl; |
| C.indent() << "setVar("RS_EXPORT_VAR_INDEX_PREFIX << VarName << ", " |
| << FieldPackerName << ", " RS_ELEM_PREFIX |
| << ET->getElementName() << ", __dimArr);" << std::endl; |
| } |
| |
| C.endFunction(); |
| } |
| return; |
| } |
| |
| void RSReflection::genGetExportVariable(Context &C, |
| const std::string &TypeName, |
| const std::string &VarName) { |
| C.startFunction(Context::AM_Public, |
| false, |
| TypeName.c_str(), |
| "get_" + VarName, |
| 0); |
| |
| C.indent() << "return "RS_EXPORT_VAR_PREFIX << VarName << ";" << std::endl; |
| |
| C.endFunction(); |
| return; |
| } |
| |
| /******************* Methods to generate script class /end *******************/ |
| |
| bool RSReflection::genCreateFieldPacker(Context &C, |
| const RSExportType *ET, |
| const char *FieldPackerName) { |
| size_t AllocSize = RSExportType::GetTypeAllocSize(ET); |
| if (AllocSize > 0) |
| C.indent() << "FieldPacker " << FieldPackerName << " = new FieldPacker(" |
| << AllocSize << ");" << std::endl; |
| else |
| return false; |
| return true; |
| } |
| |
| void RSReflection::genPackVarOfType(Context &C, |
| const RSExportType *ET, |
| const char *VarName, |
| const char *FieldPackerName) { |
| switch (ET->getClass()) { |
| case RSExportType::ExportClassPrimitive: |
| case RSExportType::ExportClassVector: { |
| C.indent() << FieldPackerName << "." |
| << GetPackerAPIName( |
| static_cast<const RSExportPrimitiveType*>(ET)) |
| << "(" << VarName << ");" << std::endl; |
| break; |
| } |
| case RSExportType::ExportClassPointer: { |
| // Must reflect as type Allocation in Java |
| const RSExportType *PointeeType = |
| static_cast<const RSExportPointerType*>(ET)->getPointeeType(); |
| |
| if (PointeeType->getClass() != RSExportType::ExportClassRecord) |
| C.indent() << FieldPackerName << ".addI32(" << VarName |
| << ".getPtr());" << std::endl; |
| else |
| C.indent() << FieldPackerName << ".addI32(" << VarName |
| << ".getAllocation().getPtr());" << std::endl; |
| break; |
| } |
| case RSExportType::ExportClassMatrix: { |
| C.indent() << FieldPackerName << ".addMatrix(" << VarName << ");" |
| << std::endl; |
| 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) |
| C.indent() << FieldPackerName << ".skip(" |
| << (FieldOffset - Pos) << ");" << std::endl; |
| |
| genPackVarOfType(C, F->getType(), FieldName.c_str(), FieldPackerName); |
| |
| // There is padding in the field type |
| if (FieldAllocSize > FieldStoreSize) |
| C.indent() << FieldPackerName << ".skip(" |
| << (FieldAllocSize - FieldStoreSize) |
| << ");" << std::endl; |
| |
| Pos = FieldOffset + FieldAllocSize; |
| } |
| |
| // There maybe some padding after the struct |
| if (RSExportType::GetTypeAllocSize(ERT) > Pos) |
| C.indent() << FieldPackerName << ".skip(" |
| << RSExportType::GetTypeAllocSize(ERT) - Pos << ");" |
| << std::endl; |
| break; |
| } |
| default: { |
| slangAssert(false && "Unknown class of type"); |
| } |
| } |
| |
| return; |
| } |
| |
| void RSReflection::genAllocateVarOfType(Context &C, |
| const RSExportType *T, |
| const std::string &VarName) { |
| switch (T->getClass()) { |
| case RSExportType::ExportClassPrimitive: { |
| // Primitive type like int in Java has its own storage once it's declared. |
| // |
| // FIXME: Should we allocate storage for RS object? |
| // if (static_cast<const RSExportPrimitiveType *>(T)->isRSObjectType()) |
| // C.indent() << VarName << " = new " << GetTypeName(T) << "();" |
| // << std::endl; |
| break; |
| } |
| case RSExportType::ExportClassPointer: { |
| // Pointer type is an instance of Allocation or a TypeClass whose value is |
| // expected to be assigned by programmer later in Java program. Therefore |
| // we don't reflect things like [VarName] = new Allocation(); |
| C.indent() << VarName << " = null;" << std::endl; |
| break; |
| } |
| case RSExportType::ExportClassConstantArray: { |
| const RSExportConstantArrayType *ECAT = |
| static_cast<const RSExportConstantArrayType *>(T); |
| const RSExportType *ElementType = ECAT->getElementType(); |
| |
| C.indent() << VarName << " = new " << GetTypeName(ElementType) |
| << "[" << ECAT->getSize() << "];" << std::endl; |
| |
| // Primitive type element doesn't need allocation code. |
| if (ElementType->getClass() != RSExportType::ExportClassPrimitive) { |
| C.indent() << "for (int $ct = 0; $ct < " << ECAT->getSize() << "; " |
| "$ct++)"; |
| C.startBlock(); |
| |
| std::string ElementVarName(VarName); |
| ElementVarName.append("[$ct]"); |
| genAllocateVarOfType(C, ElementType, ElementVarName); |
| |
| C.endBlock(); |
| } |
| break; |
| } |
| case RSExportType::ExportClassVector: |
| case RSExportType::ExportClassMatrix: |
| case RSExportType::ExportClassRecord: { |
| C.indent() << VarName << " = new " << GetTypeName(T) << "();" |
| << std::endl; |
| break; |
| } |
| } |
| return; |
| } |
| |
| void RSReflection::genNewItemBufferIfNull(Context &C, |
| const char *Index) { |
| C.indent() << "if (" RS_TYPE_ITEM_BUFFER_NAME " == null) " |
| RS_TYPE_ITEM_BUFFER_NAME " = " |
| "new " RS_TYPE_ITEM_CLASS_NAME |
| "[getType().getX() /* count */];" |
| << std::endl; |
| if (Index != NULL) |
| C.indent() << "if ("RS_TYPE_ITEM_BUFFER_NAME"[" << Index << "] == null) " |
| RS_TYPE_ITEM_BUFFER_NAME"[" << Index << "] = " |
| "new "RS_TYPE_ITEM_CLASS_NAME"();" << std::endl; |
| return; |
| } |
| |
| void RSReflection::genNewItemBufferPackerIfNull(Context &C) { |
| C.indent() << "if (" RS_TYPE_ITEM_BUFFER_PACKER_NAME " == null) " |
| RS_TYPE_ITEM_BUFFER_PACKER_NAME " = " |
| "new FieldPacker(" RS_TYPE_ITEM_CLASS_NAME |
| ".sizeof * getType().getX()/* count */" |
| ");" << std::endl; |
| return; |
| } |
| |
| /********************** Methods to generate type class **********************/ |
| bool RSReflection::genTypeClass(Context &C, |
| const RSExportRecordType *ERT, |
| std::string &ErrorMsg) { |
| std::string ClassName = ERT->getElementName(); |
| |
| if (!C.startClass(Context::AM_Public, |
| false, |
| ClassName, |
| RS_TYPE_CLASS_SUPER_CLASS_NAME, |
| ErrorMsg)) |
| return false; |
| |
| mGeneratedFileNames->push_back(ClassName); |
| |
| genTypeItemClass(C, ERT); |
| |
| // Declare item buffer and item buffer packer |
| C.indent() << "private "RS_TYPE_ITEM_CLASS_NAME" "RS_TYPE_ITEM_BUFFER_NAME"[]" |
| ";" << std::endl; |
| C.indent() << "private FieldPacker "RS_TYPE_ITEM_BUFFER_PACKER_NAME";" |
| << std::endl; |
| C.indent() << "private static java.lang.ref.WeakReference<Element> " |
| RS_TYPE_ELEMENT_REF_NAME |
| " = new java.lang.ref.WeakReference<Element>(null);" << std::endl; |
| |
| genTypeClassConstructor(C, ERT); |
| genTypeClassCopyToArrayLocal(C, ERT); |
| genTypeClassCopyToArray(C, ERT); |
| genTypeClassItemSetter(C, ERT); |
| genTypeClassItemGetter(C, ERT); |
| genTypeClassComponentSetter(C, ERT); |
| genTypeClassComponentGetter(C, ERT); |
| genTypeClassCopyAll(C, ERT); |
| genTypeClassResize(C); |
| |
| C.endClass(); |
| |
| C.resetFieldIndex(); |
| C.clearFieldIndexMap(); |
| |
| return true; |
| } |
| |
| void RSReflection::genTypeItemClass(Context &C, |
| const RSExportRecordType *ERT) { |
| C.indent() << "static public class "RS_TYPE_ITEM_CLASS_NAME; |
| C.startBlock(); |
| |
| C.indent() << "public static final int sizeof = " |
| << RSExportType::GetTypeAllocSize(ERT) << ";" << std::endl; |
| |
| // Member elements |
| C.out() << std::endl; |
| for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(), |
| FE = ERT->fields_end(); |
| FI != FE; |
| FI++) { |
| C.indent() << GetTypeName((*FI)->getType()) << " " << (*FI)->getName() |
| << ";" << std::endl; |
| } |
| |
| // Constructor |
| C.out() << std::endl; |
| C.indent() << RS_TYPE_ITEM_CLASS_NAME"()"; |
| C.startBlock(); |
| |
| for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(), |
| FE = ERT->fields_end(); |
| FI != FE; |
| FI++) { |
| const RSExportRecordType::Field *F = *FI; |
| genAllocateVarOfType(C, F->getType(), F->getName()); |
| } |
| |
| // end Constructor |
| C.endBlock(); |
| |
| // end Item class |
| C.endBlock(); |
| |
| return; |
| } |
| |
| void RSReflection::genTypeClassConstructor(Context &C, |
| const RSExportRecordType *ERT) { |
| const char *RenderScriptVar = "rs"; |
| |
| C.startFunction(Context::AM_Public, |
| true, |
| "Element", |
| "createElement", |
| 1, |
| "RenderScript", RenderScriptVar); |
| |
| // TODO(all): Fix weak-refs + multi-context issue. |
| // C.indent() << "Element e = " << RS_TYPE_ELEMENT_REF_NAME |
| // << ".get();" << std::endl; |
| // C.indent() << "if (e != null) return e;" << std::endl; |
| genBuildElement(C, "eb", ERT, RenderScriptVar, /* IsInline = */true); |
| C.indent() << "return eb.create();" << std::endl; |
| // C.indent() << "e = eb.create();" << std::endl; |
| // C.indent() << RS_TYPE_ELEMENT_REF_NAME |
| // << " = new java.lang.ref.WeakReference<Element>(e);" |
| // << std::endl; |
| // C.indent() << "return e;" << std::endl; |
| C.endFunction(); |
| |
| |
| // private with element |
| C.startFunction(Context::AM_Private, |
| false, |
| NULL, |
| C.getClassName(), |
| 1, |
| "RenderScript", RenderScriptVar); |
| C.indent() << RS_TYPE_ITEM_BUFFER_NAME" = null;" << std::endl; |
| C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME" = null;" << std::endl; |
| C.indent() << "mElement = createElement(" << RenderScriptVar << ");" |
| << std::endl; |
| C.endFunction(); |
| |
| // 1D without usage |
| C.startFunction(Context::AM_Public, |
| false, |
| NULL, |
| C.getClassName(), |
| 2, |
| "RenderScript", RenderScriptVar, |
| "int", "count"); |
| |
| C.indent() << RS_TYPE_ITEM_BUFFER_NAME" = null;" << std::endl; |
| C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME" = null;" << std::endl; |
| C.indent() << "mElement = createElement(" << RenderScriptVar << ");" |
| << std::endl; |
| // Call init() in super class |
| C.indent() << "init(" << RenderScriptVar << ", count);" << std::endl; |
| C.endFunction(); |
| |
| // 1D with usage |
| C.startFunction(Context::AM_Public, |
| false, |
| NULL, |
| C.getClassName(), |
| 3, |
| "RenderScript", RenderScriptVar, |
| "int", "count", |
| "int", "usages"); |
| |
| C.indent() << RS_TYPE_ITEM_BUFFER_NAME" = null;" << std::endl; |
| C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME" = null;" << std::endl; |
| C.indent() << "mElement = createElement(" << RenderScriptVar << ");" |
| << std::endl; |
| // Call init() in super class |
| C.indent() << "init(" << RenderScriptVar << ", count, usages);" << std::endl; |
| C.endFunction(); |
| |
| |
| // create1D with usage |
| C.startFunction(Context::AM_Public, |
| true, |
| C.getClassName().c_str(), |
| "create1D", |
| 3, |
| "RenderScript", RenderScriptVar, |
| "int", "dimX", |
| "int", "usages"); |
| C.indent() << C.getClassName() << " obj = new " << C.getClassName() << "(" |
| << RenderScriptVar << ");" << std::endl; |
| C.indent() << "obj.mAllocation = Allocation.createSized(" |
| "rs, obj.mElement, dimX, usages);" << std::endl; |
| C.indent() << "return obj;" << std::endl; |
| C.endFunction(); |
| |
| // create1D without usage |
| C.startFunction(Context::AM_Public, |
| true, |
| C.getClassName().c_str(), |
| "create1D", |
| 2, |
| "RenderScript", RenderScriptVar, |
| "int", "dimX"); |
| C.indent() << "return create1D(" << RenderScriptVar |
| << ", dimX, Allocation.USAGE_SCRIPT);" << std::endl; |
| C.endFunction(); |
| |
| |
| // create2D without usage |
| C.startFunction(Context::AM_Public, |
| true, |
| C.getClassName().c_str(), |
| "create2D", |
| 3, |
| "RenderScript", RenderScriptVar, |
| "int", "dimX", |
| "int", "dimY"); |
| C.indent() << "return create2D(" << RenderScriptVar |
| << ", dimX, dimY, Allocation.USAGE_SCRIPT);" << std::endl; |
| C.endFunction(); |
| |
| // create2D with usage |
| C.startFunction(Context::AM_Public, |
| true, |
| C.getClassName().c_str(), |
| "create2D", |
| 4, |
| "RenderScript", RenderScriptVar, |
| "int", "dimX", |
| "int", "dimY", |
| "int", "usages"); |
| |
| C.indent() << C.getClassName() << " obj = new " << C.getClassName() << "(" |
| << RenderScriptVar << ");" << std::endl; |
| C.indent() << "Type.Builder b = new Type.Builder(rs, obj.mElement);" |
| << std::endl; |
| C.indent() << "b.setX(dimX);" << std::endl; |
| C.indent() << "b.setY(dimY);" << std::endl; |
| C.indent() << "Type t = b.create();" << std::endl; |
| C.indent() << "obj.mAllocation = Allocation.createTyped(rs, t, usages);" |
| << std::endl; |
| C.indent() << "return obj;" << std::endl; |
| C.endFunction(); |
| |
| |
| // createTypeBuilder |
| C.startFunction(Context::AM_Public, |
| true, |
| "Type.Builder", |
| "createTypeBuilder", |
| 1, |
| "RenderScript", RenderScriptVar); |
| C.indent() << "Element e = createElement(" << RenderScriptVar << ");" |
| << std::endl; |
| C.indent() << "return new Type.Builder(rs, e);" << std::endl; |
| C.endFunction(); |
| |
| // createCustom with usage |
| C.startFunction(Context::AM_Public, |
| true, |
| C.getClassName().c_str(), |
| "createCustom", |
| 3, |
| "RenderScript", RenderScriptVar, |
| "Type.Builder", "tb", |
| "int", "usages"); |
| C.indent() << C.getClassName() << " obj = new " << C.getClassName() << "(" |
| << RenderScriptVar << ");" << std::endl; |
| C.indent() << "Type t = tb.create();" << std::endl; |
| C.indent() << "if (t.getElement() != obj.mElement) {" << std::endl; |
| C.indent() << " throw new RSIllegalArgumentException(" |
| "\"Type.Builder did not match expected element type.\");" |
| << std::endl; |
| C.indent() << "}" << std::endl; |
| C.indent() << "obj.mAllocation = Allocation.createTyped(rs, t, usages);" |
| << std::endl; |
| C.indent() << "return obj;" << std::endl; |
| C.endFunction(); |
| } |
| |
| |
| void RSReflection::genTypeClassCopyToArray(Context &C, |
| const RSExportRecordType *ERT) { |
| C.startFunction(Context::AM_Private, |
| false, |
| "void", |
| "copyToArray", |
| 2, |
| RS_TYPE_ITEM_CLASS_NAME, "i", |
| "int", "index"); |
| |
| genNewItemBufferPackerIfNull(C); |
| C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME |
| ".reset(index * "RS_TYPE_ITEM_CLASS_NAME".sizeof);" |
| << std::endl; |
| |
| C.indent() << "copyToArrayLocal(i, " RS_TYPE_ITEM_BUFFER_PACKER_NAME |
| ");" << std::endl; |
| |
| C.endFunction(); |
| return; |
| } |
| |
| void RSReflection::genTypeClassCopyToArrayLocal(Context &C, |
| const RSExportRecordType *ERT) { |
| C.startFunction(Context::AM_Private, |
| false, |
| "void", |
| "copyToArrayLocal", |
| 2, |
| RS_TYPE_ITEM_CLASS_NAME, "i", |
| "FieldPacker", "fp"); |
| |
| genPackVarOfType(C, ERT, "i", "fp"); |
| |
| C.endFunction(); |
| return; |
| } |
| |
| void RSReflection::genTypeClassItemSetter(Context &C, |
| const RSExportRecordType *ERT) { |
| C.startFunction(Context::AM_PublicSynchronized, |
| false, |
| "void", |
| "set", |
| 3, |
| RS_TYPE_ITEM_CLASS_NAME, "i", |
| "int", "index", |
| "boolean", "copyNow"); |
| genNewItemBufferIfNull(C, NULL); |
| C.indent() << RS_TYPE_ITEM_BUFFER_NAME"[index] = i;" << std::endl; |
| |
| C.indent() << "if (copyNow) "; |
| C.startBlock(); |
| |
| C.indent() << "copyToArray(i, index);" << std::endl; |
| C.indent() << "FieldPacker fp = new FieldPacker(" RS_TYPE_ITEM_CLASS_NAME |
| ".sizeof);" << std::endl; |
| C.indent() << "copyToArrayLocal(i, fp);" << std::endl; |
| C.indent() << "mAllocation.setFromFieldPacker(index, fp);" << std::endl; |
| |
| // End of if (copyNow) |
| C.endBlock(); |
| |
| C.endFunction(); |
| return; |
| } |
| |
| void RSReflection::genTypeClassItemGetter(Context &C, |
| const RSExportRecordType *ERT) { |
| C.startFunction(Context::AM_PublicSynchronized, |
| false, |
| RS_TYPE_ITEM_CLASS_NAME, |
| "get", |
| 1, |
| "int", "index"); |
| C.indent() << "if ("RS_TYPE_ITEM_BUFFER_NAME" == null) return null;" |
| << std::endl; |
| C.indent() << "return "RS_TYPE_ITEM_BUFFER_NAME"[index];" << std::endl; |
| C.endFunction(); |
| return; |
| } |
| |
| void RSReflection::genTypeClassComponentSetter(Context &C, |
| const RSExportRecordType *ERT) { |
| for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(), |
| FE = ERT->fields_end(); |
| FI != FE; |
| FI++) { |
| const RSExportRecordType::Field *F = *FI; |
| size_t FieldOffset = F->getOffsetInParent(); |
| size_t FieldStoreSize = RSExportType::GetTypeStoreSize(F->getType()); |
| unsigned FieldIndex = C.getFieldIndex(F); |
| |
| C.startFunction(Context::AM_PublicSynchronized, |
| false, |
| "void", |
| "set_" + F->getName(), 3, |
| "int", "index", |
| GetTypeName(F->getType()).c_str(), "v", |
| "boolean", "copyNow"); |
| genNewItemBufferPackerIfNull(C); |
| genNewItemBufferIfNull(C, "index"); |
| C.indent() << RS_TYPE_ITEM_BUFFER_NAME"[index]." << F->getName() |
| << " = v;" << std::endl; |
| |
| C.indent() << "if (copyNow) "; |
| C.startBlock(); |
| |
| if (FieldOffset > 0) |
| C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME |
| ".reset(index * "RS_TYPE_ITEM_CLASS_NAME".sizeof + " |
| << FieldOffset << ");" << std::endl; |
| else |
| C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME |
| ".reset(index * "RS_TYPE_ITEM_CLASS_NAME".sizeof);" |
| << std::endl; |
| genPackVarOfType(C, F->getType(), "v", RS_TYPE_ITEM_BUFFER_PACKER_NAME); |
| |
| C.indent() << "FieldPacker fp = new FieldPacker(" << FieldStoreSize << ");" |
| << std::endl; |
| genPackVarOfType(C, F->getType(), "v", "fp"); |
| C.indent() << "mAllocation.setFromFieldPacker(index, " << FieldIndex |
| << ", fp);" |
| << std::endl; |
| |
| // End of if (copyNow) |
| C.endBlock(); |
| |
| C.endFunction(); |
| } |
| return; |
| } |
| |
| void RSReflection::genTypeClassComponentGetter(Context &C, |
| const RSExportRecordType *ERT) { |
| for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(), |
| FE = ERT->fields_end(); |
| FI != FE; |
| FI++) { |
| const RSExportRecordType::Field *F = *FI; |
| C.startFunction(Context::AM_PublicSynchronized, |
| false, |
| GetTypeName(F->getType()).c_str(), |
| "get_" + F->getName(), |
| 1, |
| "int", "index"); |
| C.indent() << "if ("RS_TYPE_ITEM_BUFFER_NAME" == null) return " |
| << GetTypeNullValue(F->getType()) << ";" << std::endl; |
| C.indent() << "return "RS_TYPE_ITEM_BUFFER_NAME"[index]." << F->getName() |
| << ";" << std::endl; |
| C.endFunction(); |
| } |
| return; |
| } |
| |
| void RSReflection::genTypeClassCopyAll(Context &C, |
| const RSExportRecordType *ERT) { |
| C.startFunction(Context::AM_PublicSynchronized, false, "void", "copyAll", 0); |
| |
| C.indent() << "for (int ct = 0; ct < "RS_TYPE_ITEM_BUFFER_NAME".length; ct++)" |
| " copyToArray("RS_TYPE_ITEM_BUFFER_NAME"[ct], ct);" |
| << std::endl; |
| C.indent() << "mAllocation.setFromFieldPacker(0, " |
| RS_TYPE_ITEM_BUFFER_PACKER_NAME");" |
| << std::endl; |
| |
| C.endFunction(); |
| return; |
| } |
| |
| void RSReflection::genTypeClassResize(Context &C) { |
| C.startFunction(Context::AM_PublicSynchronized, |
| false, |
| "void", |
| "resize", |
| 1, |
| "int", "newSize"); |
| |
| C.indent() << "if (mItemArray != null) "; |
| C.startBlock(); |
| C.indent() << "int oldSize = mItemArray.length;" << std::endl; |
| C.indent() << "int copySize = Math.min(oldSize, newSize);" << std::endl; |
| C.indent() << "if (newSize == oldSize) return;" << std::endl; |
| C.indent() << "Item ni[] = new Item[newSize];" << std::endl; |
| C.indent() << "System.arraycopy(mItemArray, 0, ni, 0, copySize);" |
| << std::endl; |
| C.indent() << "mItemArray = ni;" << std::endl; |
| C.endBlock(); |
| C.indent() << "mAllocation.resize(newSize);" << std::endl; |
| |
| C.indent() << "if (" RS_TYPE_ITEM_BUFFER_PACKER_NAME " != null) " |
| RS_TYPE_ITEM_BUFFER_PACKER_NAME " = " |
| "new FieldPacker(" RS_TYPE_ITEM_CLASS_NAME |
| ".sizeof * getType().getX()/* count */" |
| ");" << std::endl; |
| |
| C.endFunction(); |
| return; |
| } |
| |
| /******************** Methods to generate type class /end ********************/ |
| |
| /********** Methods to create Element in Java of given record type ***********/ |
| void RSReflection::genBuildElement(Context &C, |
| const char *ElementBuilderName, |
| const RSExportRecordType *ERT, |
| const char *RenderScriptVar, |
| bool IsInline) { |
| C.indent() << "Element.Builder " << ElementBuilderName << " = " |
| "new Element.Builder(" << RenderScriptVar << ");" << std::endl; |
| |
| // eb.add(...) |
| genAddElementToElementBuilder(C, |
| ERT, |
| "", |
| ElementBuilderName, |
| RenderScriptVar, |
| /* ArraySize = */0); |
| |
| if (!IsInline) |
| C.indent() << "return " << ElementBuilderName << ".create();" << std::endl; |
| return; |
| } |
| |
| #define EB_ADD(x) do { \ |
| C.indent() << ElementBuilderName \ |
| << ".add(" << x << ", \"" << VarName << "\""; \ |
| if (ArraySize > 0) \ |
| C.out() << ", " << ArraySize; \ |
| C.out() << ");" << std::endl; \ |
| C.incFieldIndex(); \ |
| } while (false) |
| |
| void RSReflection::genAddElementToElementBuilder(Context &C, |
| const RSExportType *ET, |
| const std::string &VarName, |
| const char *ElementBuilderName, |
| const char *RenderScriptVar, |
| unsigned ArraySize) { |
| std::string ElementConstruct = GetBuiltinElementConstruct(ET); |
| |
| if (ElementConstruct != "") { |
| EB_ADD(ElementConstruct << "(" << RenderScriptVar << ")"); |
| } else { |
| if ((ET->getClass() == RSExportType::ExportClassPrimitive) || |
| (ET->getClass() == RSExportType::ExportClassVector)) { |
| const RSExportPrimitiveType *EPT = |
| static_cast<const RSExportPrimitiveType*>(ET); |
| const char *DataTypeName = |
| RSExportPrimitiveType::getRSReflectionType(EPT)->rs_type; |
| int Size = (ET->getClass() == RSExportType::ExportClassVector) ? |
| static_cast<const RSExportVectorType*>(ET)->getNumElement() : |
| 1; |
| |
| if (EPT->getClass() == RSExportType::ExportClassPrimitive) { |
| // Element.createUser() |
| EB_ADD("Element.createUser(" << RenderScriptVar |
| << ", Element.DataType." |
| << DataTypeName << ")"); |
| } else { |
| slangAssert((ET->getClass() == RSExportType::ExportClassVector) && |
| "Unexpected type."); |
| EB_ADD("Element.createVector(" << RenderScriptVar |
| << ", Element.DataType." |
| << DataTypeName << ", " |
| << Size << ")"); |
| } |
| #ifndef NDEBUG |
| } else if (ET->getClass() == RSExportType::ExportClassPointer) { |
| // Pointer type variable should be resolved in |
| // GetBuiltinElementConstruct() |
| slangAssert(false && "??"); |
| } else if (ET->getClass() == RSExportType::ExportClassMatrix) { |
| // Matrix type variable should be resolved |
| // in GetBuiltinElementConstruct() |
| slangAssert(false && "??"); |
| #endif |
| } else if (ET->getClass() == RSExportType::ExportClassConstantArray) { |
| const RSExportConstantArrayType *ECAT = |
| static_cast<const RSExportConstantArrayType *>(ET); |
| |
| const RSExportType *ElementType = ECAT->getElementType(); |
| if (ElementType->getClass() != RSExportType::ExportClassRecord) { |
| genAddElementToElementBuilder(C, |
| ECAT->getElementType(), |
| VarName, |
| ElementBuilderName, |
| RenderScriptVar, |
| ECAT->getSize()); |
| } else { |
| std::string NewElementBuilderName(ElementBuilderName); |
| NewElementBuilderName.append(1, '_'); |
| |
| genBuildElement(C, |
| NewElementBuilderName.c_str(), |
| static_cast<const RSExportRecordType*>(ElementType), |
| RenderScriptVar, |
| /* IsInline = */true); |
| ArraySize = ECAT->getSize(); |
| EB_ADD(NewElementBuilderName << ".create()"); |
| } |
| } else if (ET->getClass() == RSExportType::ExportClassRecord) { |
| // Simalar to case of RSExportType::ExportClassRecord in genPackVarOfType. |
| // |
| // TODO(zonr): Generalize these two function such that there's no |
| // duplicated codes. |
| const RSExportRecordType *ERT = |
| static_cast<const RSExportRecordType*>(ET); |
| int Pos = 0; // relative pos from now on |
| |
| for (RSExportRecordType::const_field_iterator I = ERT->fields_begin(), |
| E = ERT->fields_end(); |
| I != E; |
| I++) { |
| const RSExportRecordType::Field *F = *I; |
| std::string FieldName; |
| int FieldOffset = F->getOffsetInParent(); |
| int FieldStoreSize = RSExportType::GetTypeStoreSize(F->getType()); |
| int FieldAllocSize = RSExportType::GetTypeAllocSize(F->getType()); |
| |
| if (!VarName.empty()) |
| FieldName = VarName + "." + F->getName(); |
| else |
| FieldName = F->getName(); |
| |
| // Alignment |
| genAddPaddingToElementBuiler(C, |
| (FieldOffset - Pos), |
| ElementBuilderName, |
| RenderScriptVar); |
| |
| // eb.add(...) |
| C.addFieldIndexMapping(F); |
| if (F->getType()->getClass() != RSExportType::ExportClassRecord) { |
| genAddElementToElementBuilder(C, |
| F->getType(), |
| FieldName, |
| ElementBuilderName, |
| RenderScriptVar, |
| 0); |
| } else { |
| std::string NewElementBuilderName(ElementBuilderName); |
| NewElementBuilderName.append(1, '_'); |
| |
| genBuildElement(C, |
| NewElementBuilderName.c_str(), |
| static_cast<const RSExportRecordType*>(F->getType()), |
| RenderScriptVar, |
| /* IsInline = */true); |
| |
| const std::string &VarName = FieldName; // Hack for EB_ADD macro |
| EB_ADD(NewElementBuilderName << ".create()"); |
| } |
| |
| if (mRSContext->getTargetAPI() < SLANG_ICS_TARGET_API) { |
| // There is padding within the field type. This is only necessary |
| // for HC-targeted APIs. |
| genAddPaddingToElementBuiler(C, |
| (FieldAllocSize - FieldStoreSize), |
| ElementBuilderName, |
| RenderScriptVar); |
| } |
| |
| Pos = FieldOffset + FieldAllocSize; |
| } |
| |
| // There maybe some padding after the struct |
| size_t RecordAllocSize = RSExportType::GetTypeAllocSize(ERT); |
| |
| genAddPaddingToElementBuiler(C, |
| RecordAllocSize - Pos, |
| ElementBuilderName, |
| RenderScriptVar); |
| } else { |
| slangAssert(false && "Unknown class of type"); |
| } |
| } |
| } |
| |
| void RSReflection::genAddPaddingToElementBuiler(Context &C, |
| int PaddingSize, |
| const char *ElementBuilderName, |
| const char *RenderScriptVar) { |
| unsigned ArraySize = 0; // Hack the EB_ADD macro |
| while (PaddingSize > 0) { |
| const std::string &VarName = C.createPaddingField(); |
| if (PaddingSize >= 4) { |
| EB_ADD("Element.U32(" << RenderScriptVar << ")"); |
| PaddingSize -= 4; |
| } else if (PaddingSize >= 2) { |
| EB_ADD("Element.U16(" << RenderScriptVar << ")"); |
| PaddingSize -= 2; |
| } else if (PaddingSize >= 1) { |
| EB_ADD("Element.U8(" << RenderScriptVar << ")"); |
| PaddingSize -= 1; |
| } |
| } |
| return; |
| } |
| |
| #undef EB_ADD |
| /******** Methods to create Element in Java of given record type /end ********/ |
| |
| bool RSReflection::reflect(const std::string &OutputPathBase, |
| const std::string &OutputPackageName, |
| const std::string &InputFileName, |
| const std::string &OutputBCFileName) { |
| Context *C = NULL; |
| std::string ResourceId = ""; |
| std::string PaddingPrefix = ""; |
| |
| if (mRSContext->getTargetAPI() < SLANG_ICS_TARGET_API) { |
| PaddingPrefix = "#padding_"; |
| } else { |
| PaddingPrefix = "#rs_padding_"; |
| } |
| |
| if (!GetClassNameFromFileName(OutputBCFileName, ResourceId)) |
| return false; |
| |
| if (ResourceId.empty()) |
| ResourceId = "<Resource ID>"; |
| |
| if (OutputPackageName.empty() || OutputPackageName == "-") |
| C = new Context(OutputPathBase, InputFileName, "<Package Name>", |
| ResourceId, PaddingPrefix, true); |
| else |
| C = new Context(OutputPathBase, InputFileName, OutputPackageName, |
| ResourceId, PaddingPrefix, false); |
| |
| if (C != NULL) { |
| std::string ErrorMsg, ScriptClassName; |
| // class ScriptC_<ScriptName> |
| if (!GetClassNameFromFileName(InputFileName, ScriptClassName)) |
| return false; |
| |
| if (ScriptClassName.empty()) |
| ScriptClassName = "<Input Script Name>"; |
| |
| ScriptClassName.insert(0, RS_SCRIPT_CLASS_NAME_PREFIX); |
| |
| if (mRSContext->getLicenseNote() != NULL) { |
| C->setLicenseNote(*(mRSContext->getLicenseNote())); |
| } |
| |
| if (!genScriptClass(*C, ScriptClassName, ErrorMsg)) { |
| std::cerr << "Failed to generate class " << ScriptClassName << " (" |
| << ErrorMsg << ")" << std::endl; |
| return false; |
| } |
| |
| mGeneratedFileNames->push_back(ScriptClassName); |
| |
| // class ScriptField_<TypeName> |
| for (RSContext::const_export_type_iterator TI = |
| mRSContext->export_types_begin(), |
| TE = mRSContext->export_types_end(); |
| TI != TE; |
| TI++) { |
| const RSExportType *ET = TI->getValue(); |
| |
| if (ET->getClass() == RSExportType::ExportClassRecord) { |
| const RSExportRecordType *ERT = |
| static_cast<const RSExportRecordType*>(ET); |
| |
| if (!ERT->isArtificial() && !genTypeClass(*C, ERT, ErrorMsg)) { |
| std::cerr << "Failed to generate type class for struct '" |
| << ERT->getName() << "' (" << ErrorMsg << ")" << std::endl; |
| return false; |
| } |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| /************************** RSReflection::Context **************************/ |
| const char *const RSReflection::Context::ApacheLicenseNote = |
| "/*\n" |
| " * Copyright (C) 2011-2012 The Android Open Source Project\n" |
| " *\n" |
| " * Licensed under the Apache License, Version 2.0 (the \"License\");\n" |
| " * you may not use this file except in compliance with the License.\n" |
| " * You may obtain a copy of the License at\n" |
| " *\n" |
| " * http://www.apache.org/licenses/LICENSE-2.0\n" |
| " *\n" |
| " * Unless required by applicable law or agreed to in writing, software\n" |
| " * distributed under the License is distributed on an \"AS IS\" BASIS,\n" |
| " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or " |
| "implied.\n" |
| " * See the License for the specific language governing permissions and\n" |
| " * limitations under the License.\n" |
| " */\n" |
| "\n"; |
| |
| const char *const RSReflection::Context::Import[] = { |
| // Renderscript java class |
| "android.renderscript.*", |
| // Import R |
| "android.content.res.Resources", |
| // Import for debugging |
| // "android.util.Log", |
| }; |
| |
| bool RSReflection::Context::openClassFile(const std::string &ClassName, |
| std::string &ErrorMsg) { |
| if (!mUseStdout) { |
| mOF.clear(); |
| std::string Path = |
| RSSlangReflectUtils::ComputePackagedPath(mOutputPathBase.c_str(), |
| mPackageName.c_str()); |
| |
| if (!SlangUtils::CreateDirectoryWithParents(Path, &ErrorMsg)) |
| return false; |
| |
| std::string ClassFile = Path + OS_PATH_SEPARATOR_STR + ClassName + ".java"; |
| |
| mOF.open(ClassFile.c_str()); |
| if (!mOF.good()) { |
| ErrorMsg = "failed to open file '" + ClassFile + "' for write"; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| const char *RSReflection::Context::AccessModifierStr(AccessModifier AM) { |
| switch (AM) { |
| case AM_Public: return "public"; break; |
| case AM_Protected: return "protected"; break; |
| case AM_Private: return "private"; break; |
| case AM_PublicSynchronized: return "public synchronized"; break; |
| default: return ""; break; |
| } |
| } |
| |
| bool RSReflection::Context::startClass(AccessModifier AM, |
| bool IsStatic, |
| const std::string &ClassName, |
| const char *SuperClassName, |
| std::string &ErrorMsg) { |
| if (mVerbose) |
| std::cout << "Generating " << ClassName << ".java ..." << std::endl; |
| |
| // Open file for class |
| if (!openClassFile(ClassName, ErrorMsg)) |
| return false; |
| |
| // License |
| out() << mLicenseNote; |
| |
| // Notice of generated file |
| out() << "/*" << std::endl; |
| out() << " * This file is auto-generated. DO NOT MODIFY!" << std::endl; |
| out() << " * The source Renderscript file: " << mInputRSFile << std::endl; |
| out() << " */" << std::endl; |
| |
| // Package |
| if (!mPackageName.empty()) |
| out() << "package " << mPackageName << ";" << std::endl; |
| out() << std::endl; |
| |
| // Imports |
| for (unsigned i = 0; i < (sizeof(Import) / sizeof(const char*)); i++) |
| out() << "import " << Import[i] << ";" << std::endl; |
| out() << std::endl; |
| |
| // All reflected classes should be annotated as hidden, so that they won't |
| // be exposed in SDK. |
| out() << "/**" << std::endl; |
| out() << " * @hide" << std::endl; |
| out() << " */" << std::endl; |
| |
| out() << AccessModifierStr(AM) << ((IsStatic) ? " static" : "") << " class " |
| << ClassName; |
| if (SuperClassName != NULL) |
| out() << " extends " << SuperClassName; |
| |
| startBlock(); |
| |
| mClassName = ClassName; |
| |
| return true; |
| } |
| |
| void RSReflection::Context::endClass() { |
| endBlock(); |
| if (!mUseStdout) |
| mOF.close(); |
| clear(); |
| return; |
| } |
| |
| void RSReflection::Context::startBlock(bool ShouldIndent) { |
| if (ShouldIndent) |
| indent() << "{" << std::endl; |
| else |
| out() << " {" << std::endl; |
| incIndentLevel(); |
| return; |
| } |
| |
| void RSReflection::Context::endBlock() { |
| decIndentLevel(); |
| indent() << "}" << std::endl << std::endl; |
| return; |
| } |
| |
| void RSReflection::Context::startTypeClass(const std::string &ClassName) { |
| indent() << "public static class " << ClassName; |
| startBlock(); |
| return; |
| } |
| |
| void RSReflection::Context::endTypeClass() { |
| endBlock(); |
| return; |
| } |
| |
| void RSReflection::Context::startFunction(AccessModifier AM, |
| bool IsStatic, |
| const char *ReturnType, |
| const std::string &FunctionName, |
| int Argc, ...) { |
| ArgTy Args; |
| va_list vl; |
| va_start(vl, Argc); |
| |
| for (int i = 0; i < Argc; i++) { |
| const char *ArgType = va_arg(vl, const char*); |
| const char *ArgName = va_arg(vl, const char*); |
| |
| Args.push_back(std::make_pair(ArgType, ArgName)); |
| } |
| va_end(vl); |
| |
| startFunction(AM, IsStatic, ReturnType, FunctionName, Args); |
| |
| return; |
| } |
| |
| void RSReflection::Context::startFunction(AccessModifier AM, |
| bool IsStatic, |
| const char *ReturnType, |
| const std::string &FunctionName, |
| const ArgTy &Args) { |
| indent() << AccessModifierStr(AM) << ((IsStatic) ? " static " : " ") |
| << ((ReturnType) ? ReturnType : "") << " " << FunctionName << "("; |
| |
| bool FirstArg = true; |
| for (ArgTy::const_iterator I = Args.begin(), E = Args.end(); |
| I != E; |
| I++) { |
| if (!FirstArg) |
| out() << ", "; |
| else |
| FirstArg = false; |
| |
| out() << I->first << " " << I->second; |
| } |
| |
| out() << ")"; |
| startBlock(); |
| |
| return; |
| } |
| |
| void RSReflection::Context::endFunction() { |
| endBlock(); |
| return; |
| } |
| |
| } // namespace slang |
