slang_rs_reflection.cpp revision 82754d87921c94e70562aa977cc92e28fc38b1d0 
1/*
2 * Copyright 2010-2012, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "slang_rs_reflection.h"
18
19#include <sys/stat.h>
20
21#include <cstdarg>
22#include <cctype>
23
24#include <algorithm>
25#include <sstream>
26#include <string>
27#include <utility>
28
29#include "llvm/ADT/APFloat.h"
30#include "llvm/ADT/StringExtras.h"
31
32#include "os_sep.h"
33#include "slang_rs_context.h"
34#include "slang_rs_export_var.h"
35#include "slang_rs_export_foreach.h"
36#include "slang_rs_export_func.h"
37#include "slang_rs_reflect_utils.h"
38#include "slang_version.h"
39#include "slang_utils.h"
40
41#include "slang_rs_reflection_base.h"
42
43#define RS_SCRIPT_CLASS_NAME_PREFIX      "ScriptC_"
44#define RS_SCRIPT_CLASS_SUPER_CLASS_NAME "ScriptC"
45
46#define RS_TYPE_CLASS_SUPER_CLASS_NAME   ".Script.FieldBase"
47
48#define RS_TYPE_ITEM_CLASS_NAME          "Item"
49
50#define RS_TYPE_ITEM_BUFFER_NAME         "mItemArray"
51#define RS_TYPE_ITEM_BUFFER_PACKER_NAME  "mIOBuffer"
52#define RS_TYPE_ELEMENT_REF_NAME         "mElementCache"
53
54#define RS_EXPORT_VAR_INDEX_PREFIX       "mExportVarIdx_"
55#define RS_EXPORT_VAR_PREFIX             "mExportVar_"
56#define RS_EXPORT_VAR_ELEM_PREFIX        "mExportVarElem_"
57#define RS_EXPORT_VAR_DIM_PREFIX         "mExportVarDim_"
58#define RS_EXPORT_VAR_CONST_PREFIX       "const_"
59
60#define RS_ELEM_PREFIX                   "__"
61
62#define RS_FP_PREFIX                     "__rs_fp_"
63
64#define RS_RESOURCE_NAME                 "__rs_resource_name"
65
66#define RS_EXPORT_FUNC_INDEX_PREFIX      "mExportFuncIdx_"
67#define RS_EXPORT_FOREACH_INDEX_PREFIX   "mExportForEachIdx_"
68
69#define RS_EXPORT_VAR_ALLOCATION_PREFIX  "mAlloction_"
70#define RS_EXPORT_VAR_DATA_STORAGE_PREFIX "mData_"
71
72namespace slang {
73
74// Some utility function using internal in RSReflection
75static bool GetClassNameFromFileName(const std::string &FileName,
76                                     std::string &ClassName) {
77  ClassName.clear();
78
79  if (FileName.empty() || (FileName == "-"))
80    return true;
81
82  ClassName =
83      RSSlangReflectUtils::JavaClassNameFromRSFileName(FileName.c_str());
84
85  return true;
86}
87
88static const char *GetMatrixTypeName(const RSExportMatrixType *EMT) {
89  static const char *MatrixTypeJavaNameMap[] = {
90    /* 2x2 */ "Matrix2f",
91    /* 3x3 */ "Matrix3f",
92    /* 4x4 */ "Matrix4f",
93  };
94  unsigned Dim = EMT->getDim();
95
96  if ((Dim - 2) < (sizeof(MatrixTypeJavaNameMap) / sizeof(const char*)))
97    return MatrixTypeJavaNameMap[ EMT->getDim() - 2 ];
98
99  slangAssert(false && "GetMatrixTypeName : Unsupported matrix dimension");
100  return NULL;
101}
102
103static const char *GetVectorAccessor(unsigned Index) {
104  static const char *VectorAccessorMap[] = {
105    /* 0 */ "x",
106    /* 1 */ "y",
107    /* 2 */ "z",
108    /* 3 */ "w",
109  };
110
111  slangAssert((Index < (sizeof(VectorAccessorMap) / sizeof(const char*))) &&
112              "Out-of-bound index to access vector member");
113
114  return VectorAccessorMap[Index];
115}
116
117static const char *GetPackerAPIName(const RSExportPrimitiveType *EPT) {
118  static const char *PrimitiveTypePackerAPINameMap[] = {
119    "",         // RSExportPrimitiveType::DataTypeFloat16
120    "addF32",   // RSExportPrimitiveType::DataTypeFloat32
121    "addF64",   // RSExportPrimitiveType::DataTypeFloat64
122    "addI8",    // RSExportPrimitiveType::DataTypeSigned8
123    "addI16",   // RSExportPrimitiveType::DataTypeSigned16
124    "addI32",   // RSExportPrimitiveType::DataTypeSigned32
125    "addI64",   // RSExportPrimitiveType::DataTypeSigned64
126    "addU8",    // RSExportPrimitiveType::DataTypeUnsigned8
127    "addU16",   // RSExportPrimitiveType::DataTypeUnsigned16
128    "addU32",   // RSExportPrimitiveType::DataTypeUnsigned32
129    "addU64",   // RSExportPrimitiveType::DataTypeUnsigned64
130    "addBoolean",  // RSExportPrimitiveType::DataTypeBoolean
131
132    "addU16",   // RSExportPrimitiveType::DataTypeUnsigned565
133    "addU16",   // RSExportPrimitiveType::DataTypeUnsigned5551
134    "addU16",   // RSExportPrimitiveType::DataTypeUnsigned4444
135
136    "addMatrix",   // RSExportPrimitiveType::DataTypeRSMatrix2x2
137    "addMatrix",   // RSExportPrimitiveType::DataTypeRSMatrix3x3
138    "addMatrix",   // RSExportPrimitiveType::DataTypeRSMatrix4x4
139
140    "addObj",   // RSExportPrimitiveType::DataTypeRSElement
141    "addObj",   // RSExportPrimitiveType::DataTypeRSType
142    "addObj",   // RSExportPrimitiveType::DataTypeRSAllocation
143    "addObj",   // RSExportPrimitiveType::DataTypeRSSampler
144    "addObj",   // RSExportPrimitiveType::DataTypeRSScript
145    "addObj",   // RSExportPrimitiveType::DataTypeRSMesh
146    "addObj",   // RSExportPrimitiveType::DataTypeRSPath
147    "addObj",   // RSExportPrimitiveType::DataTypeRSProgramFragment
148    "addObj",   // RSExportPrimitiveType::DataTypeRSProgramVertex
149    "addObj",   // RSExportPrimitiveType::DataTypeRSProgramRaster
150    "addObj",   // RSExportPrimitiveType::DataTypeRSProgramStore
151    "addObj",   // RSExportPrimitiveType::DataTypeRSFont
152  };
153  unsigned TypeId = EPT->getType();
154
155  if (TypeId < (sizeof(PrimitiveTypePackerAPINameMap) / sizeof(const char*)))
156    return PrimitiveTypePackerAPINameMap[ EPT->getType() ];
157
158  slangAssert(false && "GetPackerAPIName : Unknown primitive data type");
159  return NULL;
160}
161
162static std::string GetTypeName(const RSExportType *ET, bool Brackets = true) {
163  switch (ET->getClass()) {
164    case RSExportType::ExportClassPrimitive: {
165      return RSExportPrimitiveType::getRSReflectionType(
166          static_cast<const RSExportPrimitiveType*>(ET))->java_name;
167    }
168    case RSExportType::ExportClassPointer: {
169      const RSExportType *PointeeType =
170          static_cast<const RSExportPointerType*>(ET)->getPointeeType();
171
172      if (PointeeType->getClass() != RSExportType::ExportClassRecord)
173        return "Allocation";
174      else
175        return PointeeType->getElementName();
176    }
177    case RSExportType::ExportClassVector: {
178      const RSExportVectorType *EVT =
179          static_cast<const RSExportVectorType*>(ET);
180      std::stringstream VecName;
181      VecName << EVT->getRSReflectionType(EVT)->rs_java_vector_prefix
182              << EVT->getNumElement();
183      return VecName.str();
184    }
185    case RSExportType::ExportClassMatrix: {
186      return GetMatrixTypeName(static_cast<const RSExportMatrixType*>(ET));
187    }
188    case RSExportType::ExportClassConstantArray: {
189      const RSExportConstantArrayType* CAT =
190          static_cast<const RSExportConstantArrayType*>(ET);
191      std::string ElementTypeName = GetTypeName(CAT->getElementType());
192      if (Brackets) {
193        ElementTypeName.append("[]");
194      }
195      return ElementTypeName;
196    }
197    case RSExportType::ExportClassRecord: {
198      return ET->getElementName() + "."RS_TYPE_ITEM_CLASS_NAME;
199    }
200    default: {
201      slangAssert(false && "Unknown class of type");
202    }
203  }
204
205  return "";
206}
207
208static const char *GetTypeNullValue(const RSExportType *ET) {
209  switch (ET->getClass()) {
210    case RSExportType::ExportClassPrimitive: {
211      const RSExportPrimitiveType *EPT =
212          static_cast<const RSExportPrimitiveType*>(ET);
213      if (EPT->isRSObjectType())
214        return "null";
215      else if (EPT->getType() == RSExportPrimitiveType::DataTypeBoolean)
216        return "false";
217      else
218        return "0";
219      break;
220    }
221    case RSExportType::ExportClassPointer:
222    case RSExportType::ExportClassVector:
223    case RSExportType::ExportClassMatrix:
224    case RSExportType::ExportClassConstantArray:
225    case RSExportType::ExportClassRecord: {
226      return "null";
227      break;
228    }
229    default: {
230      slangAssert(false && "Unknown class of type");
231    }
232  }
233  return "";
234}
235
236static std::string GetBuiltinElementConstruct(const RSExportType *ET) {
237  if (ET->getClass() == RSExportType::ExportClassPrimitive) {
238    return std::string("Element.") + ET->getElementName();
239  } else if (ET->getClass() == RSExportType::ExportClassVector) {
240    const RSExportVectorType *EVT = static_cast<const RSExportVectorType*>(ET);
241    if (EVT->getType() == RSExportPrimitiveType::DataTypeFloat32) {
242      if (EVT->getNumElement() == 2)
243        return "Element.F32_2";
244      else if (EVT->getNumElement() == 3)
245        return "Element.F32_3";
246      else if (EVT->getNumElement() == 4)
247        return "Element.F32_4";
248    } else if (EVT->getType() == RSExportPrimitiveType::DataTypeUnsigned8) {
249      if (EVT->getNumElement() == 4)
250        return "Element.U8_4";
251    }
252  } else if (ET->getClass() == RSExportType::ExportClassMatrix) {
253    const RSExportMatrixType *EMT = static_cast<const RSExportMatrixType *>(ET);
254    switch (EMT->getDim()) {
255      case 2: return "Element.MATRIX_2X2";
256      case 3: return "Element.MATRIX_3X3";
257      case 4: return "Element.MATRIX_4X4";
258      default: slangAssert(false && "Unsupported dimension of matrix");
259    }
260  }
261  // RSExportType::ExportClassPointer can't be generated in a struct.
262
263  return "";
264}
265
266
267/********************** Methods to generate script class **********************/
268bool RSReflection::genScriptClass(Context &C,
269                                  const std::string &ClassName,
270                                  std::string &ErrorMsg) {
271  if (!C.startClass(Context::AM_Public,
272                    false,
273                    ClassName,
274                    RS_SCRIPT_CLASS_SUPER_CLASS_NAME,
275                    ErrorMsg))
276    return false;
277
278  genScriptClassConstructor(C);
279
280  // Reflect export variable
281  for (RSContext::const_export_var_iterator I = mRSContext->export_vars_begin(),
282           E = mRSContext->export_vars_end();
283       I != E;
284       I++)
285    genExportVariable(C, *I);
286
287  // Reflect export for each functions (only available on ICS+)
288  if (mRSContext->getTargetAPI() >= SLANG_ICS_TARGET_API) {
289    for (RSContext::const_export_foreach_iterator
290             I = mRSContext->export_foreach_begin(),
291             E = mRSContext->export_foreach_end();
292         I != E; I++)
293      genExportForEach(C, *I);
294  }
295
296  // Reflect export function
297  for (RSContext::const_export_func_iterator
298           I = mRSContext->export_funcs_begin(),
299           E = mRSContext->export_funcs_end();
300       I != E; I++)
301    genExportFunction(C, *I);
302
303  C.endClass();
304
305  return true;
306}
307
308void RSReflection::genScriptClassConstructor(Context &C) {
309  // Provide a simple way to reference this object.
310  C.indent() << "private static final String " RS_RESOURCE_NAME " = \""
311             << C.getResourceId()
312             << "\";" << std::endl;
313
314  // Generate a simple constructor with only a single parameter (the rest
315  // can be inferred from information we already have).
316  C.indent() << "// Constructor" << std::endl;
317  C.startFunction(Context::AM_Public,
318                  false,
319                  NULL,
320                  C.getClassName(),
321                  1,
322                  "RenderScript", "rs");
323  // Call alternate constructor with required parameters.
324  // Look up the proper raw bitcode resource id via the context.
325  C.indent() << "this(rs," << std::endl;
326  C.indent() << "     rs.getApplicationContext().getResources()," << std::endl;
327  C.indent() << "     rs.getApplicationContext().getResources()."
328                "getIdentifier(" << std::endl;
329  C.indent() << "         " RS_RESOURCE_NAME ", \"raw\"," << std::endl;
330  C.indent() << "         rs.getApplicationContext().getPackageName()));"
331             << std::endl;
332  C.endFunction();
333
334  // Alternate constructor (legacy) with 3 original parameters.
335  C.startFunction(Context::AM_Public,
336                  false,
337                  NULL,
338                  C.getClassName(),
339                  3,
340                  "RenderScript", "rs",
341                  "Resources", "resources",
342                  "int", "id");
343  // Call constructor of super class
344  C.indent() << "super(rs, resources, id);" << std::endl;
345
346  // If an exported variable has initial value, reflect it
347
348  for (RSContext::const_export_var_iterator I = mRSContext->export_vars_begin(),
349           E = mRSContext->export_vars_end();
350       I != E;
351       I++) {
352    const RSExportVar *EV = *I;
353    if (!EV->getInit().isUninit()) {
354      genInitExportVariable(C, EV->getType(), EV->getName(), EV->getInit());
355    } else if (EV->getArraySize()) {
356      // Always create an initial zero-init array object.
357      C.indent() << RS_EXPORT_VAR_PREFIX << EV->getName() << " = new "
358                 << GetTypeName(EV->getType(), false) << "["
359                 << EV->getArraySize() << "];" << std::endl;
360      size_t NumInits = EV->getNumInits();
361      const RSExportConstantArrayType *ECAT =
362          static_cast<const RSExportConstantArrayType*>(EV->getType());
363      const RSExportType *ET = ECAT->getElementType();
364      for (size_t i = 0; i < NumInits; i++) {
365        std::stringstream Name;
366        Name << EV->getName() << "[" << i << "]";
367        genInitExportVariable(C, ET, Name.str(), EV->getInitArray(i));
368      }
369    }
370    if (mRSContext->getTargetAPI() >= SLANG_JB_TARGET_API) {
371      genTypeInstance(C, EV->getType());
372    }
373    genFieldPackerInstance(C, EV->getType());
374  }
375
376  for (RSContext::const_export_foreach_iterator
377           I = mRSContext->export_foreach_begin(),
378           E = mRSContext->export_foreach_end();
379       I != E;
380       I++) {
381    const RSExportForEach *EF = *I;
382
383    const RSExportType *IET = EF->getInType();
384    if (IET) {
385      genTypeInstanceFromPointer(C, IET);
386    }
387    const RSExportType *OET = EF->getOutType();
388    if (OET) {
389      genTypeInstanceFromPointer(C, OET);
390    }
391  }
392
393  C.endFunction();
394
395  for (std::set<std::string>::iterator I = C.mTypesToCheck.begin(),
396                                       E = C.mTypesToCheck.end();
397       I != E;
398       I++) {
399    C.indent() << "private Element " RS_ELEM_PREFIX << *I << ";" << std::endl;
400  }
401
402  for (std::set<std::string>::iterator I = C.mFieldPackerTypes.begin(),
403                                       E = C.mFieldPackerTypes.end();
404       I != E;
405       I++) {
406    C.indent() << "private FieldPacker " RS_FP_PREFIX << *I << ";" << std::endl;
407  }
408
409  return;
410}
411
412void RSReflection::genInitBoolExportVariable(Context &C,
413                                             const std::string &VarName,
414                                             const clang::APValue &Val) {
415  slangAssert(!Val.isUninit() && "Not a valid initializer");
416
417  C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = ";
418  slangAssert((Val.getKind() == clang::APValue::Int) &&
419              "Bool type has wrong initial APValue");
420
421  C.out() << ((Val.getInt().getSExtValue() == 0) ? "false" : "true")
422          << ";" << std::endl;
423
424  return;
425}
426
427void RSReflection::genInitPrimitiveExportVariable(
428      Context &C,
429      const std::string &VarName,
430      const clang::APValue &Val) {
431  slangAssert(!Val.isUninit() && "Not a valid initializer");
432
433  C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = ";
434  C.out() << RSReflectionBase::genInitValue(Val);
435  C.out() << ";" << std::endl;
436
437  return;
438}
439
440void RSReflection::genInitExportVariable(Context &C,
441                                         const RSExportType *ET,
442                                         const std::string &VarName,
443                                         const clang::APValue &Val) {
444  slangAssert(!Val.isUninit() && "Not a valid initializer");
445
446  switch (ET->getClass()) {
447    case RSExportType::ExportClassPrimitive: {
448      const RSExportPrimitiveType *EPT =
449          static_cast<const RSExportPrimitiveType*>(ET);
450      if (EPT->getType() == RSExportPrimitiveType::DataTypeBoolean) {
451        genInitBoolExportVariable(C, VarName, Val);
452      } else {
453        genInitPrimitiveExportVariable(C, VarName, Val);
454      }
455      break;
456    }
457    case RSExportType::ExportClassPointer: {
458      if (!Val.isInt() || Val.getInt().getSExtValue() != 0)
459        std::cout << "Initializer which is non-NULL to pointer type variable "
460                     "will be ignored" << std::endl;
461      break;
462    }
463    case RSExportType::ExportClassVector: {
464      const RSExportVectorType *EVT =
465          static_cast<const RSExportVectorType*>(ET);
466      switch (Val.getKind()) {
467        case clang::APValue::Int:
468        case clang::APValue::Float: {
469          for (unsigned i = 0; i < EVT->getNumElement(); i++) {
470            std::string Name =  VarName + "." + GetVectorAccessor(i);
471            genInitPrimitiveExportVariable(C, Name, Val);
472          }
473          break;
474        }
475        case clang::APValue::Vector: {
476          std::stringstream VecName;
477          VecName << EVT->getRSReflectionType(EVT)->rs_java_vector_prefix
478                  << EVT->getNumElement();
479          C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = new "
480                     << VecName.str() << "();" << std::endl;
481
482          unsigned NumElements =
483              std::min(static_cast<unsigned>(EVT->getNumElement()),
484                       Val.getVectorLength());
485          for (unsigned i = 0; i < NumElements; i++) {
486            const clang::APValue &ElementVal = Val.getVectorElt(i);
487            std::string Name = VarName + "." + GetVectorAccessor(i);
488            genInitPrimitiveExportVariable(C, Name, ElementVal);
489          }
490          break;
491        }
492        case clang::APValue::MemberPointer:
493        case clang::APValue::Uninitialized:
494        case clang::APValue::ComplexInt:
495        case clang::APValue::ComplexFloat:
496        case clang::APValue::LValue:
497        case clang::APValue::Array:
498        case clang::APValue::Struct:
499        case clang::APValue::Union:
500        case clang::APValue::AddrLabelDiff: {
501          slangAssert(false && "Unexpected type of value of initializer.");
502        }
503      }
504      break;
505    }
506    // TODO(zonr): Resolving initializer of a record (and matrix) type variable
507    // is complex. It cannot obtain by just simply evaluating the initializer
508    // expression.
509    case RSExportType::ExportClassMatrix:
510    case RSExportType::ExportClassConstantArray:
511    case RSExportType::ExportClassRecord: {
512#if 0
513      unsigned InitIndex = 0;
514      const RSExportRecordType *ERT =
515          static_cast<const RSExportRecordType*>(ET);
516
517      slangAssert((Val.getKind() == clang::APValue::Vector) &&
518          "Unexpected type of initializer for record type variable");
519
520      C.indent() << RS_EXPORT_VAR_PREFIX << VarName
521                 << " = new " << ERT->getElementName()
522                 <<  "."RS_TYPE_ITEM_CLASS_NAME"();" << std::endl;
523
524      for (RSExportRecordType::const_field_iterator I = ERT->fields_begin(),
525               E = ERT->fields_end();
526           I != E;
527           I++) {
528        const RSExportRecordType::Field *F = *I;
529        std::string FieldName = VarName + "." + F->getName();
530
531        if (InitIndex > Val.getVectorLength())
532          break;
533
534        genInitPrimitiveExportVariable(C,
535                                       FieldName,
536                                       Val.getVectorElt(InitIndex++));
537      }
538#endif
539      slangAssert(false && "Unsupported initializer for record/matrix/constant "
540                           "array type variable currently");
541      break;
542    }
543    default: {
544      slangAssert(false && "Unknown class of type");
545    }
546  }
547  return;
548}
549
550void RSReflection::genExportVariable(Context &C, const RSExportVar *EV) {
551  const RSExportType *ET = EV->getType();
552
553  C.indent() << "private final static int "RS_EXPORT_VAR_INDEX_PREFIX
554             << EV->getName() << " = " << C.getNextExportVarSlot() << ";"
555             << std::endl;
556
557  switch (ET->getClass()) {
558    case RSExportType::ExportClassPrimitive: {
559      genPrimitiveTypeExportVariable(C, EV);
560      break;
561    }
562    case RSExportType::ExportClassPointer: {
563      genPointerTypeExportVariable(C, EV);
564      break;
565    }
566    case RSExportType::ExportClassVector: {
567      genVectorTypeExportVariable(C, EV);
568      break;
569    }
570    case RSExportType::ExportClassMatrix: {
571      genMatrixTypeExportVariable(C, EV);
572      break;
573    }
574    case RSExportType::ExportClassConstantArray: {
575      genConstantArrayTypeExportVariable(C, EV);
576      break;
577    }
578    case RSExportType::ExportClassRecord: {
579      genRecordTypeExportVariable(C, EV);
580      break;
581    }
582    default: {
583      slangAssert(false && "Unknown class of type");
584    }
585  }
586
587  return;
588}
589
590void RSReflection::genExportFunction(Context &C, const RSExportFunc *EF) {
591  C.indent() << "private final static int "RS_EXPORT_FUNC_INDEX_PREFIX
592             << EF->getName() << " = " << C.getNextExportFuncSlot() << ";"
593             << std::endl;
594
595  // invoke_*()
596  Context::ArgTy Args;
597
598  if (EF->hasParam()) {
599    for (RSExportFunc::const_param_iterator I = EF->params_begin(),
600             E = EF->params_end();
601         I != E;
602         I++) {
603      Args.push_back(std::make_pair(GetTypeName((*I)->getType()),
604                                    (*I)->getName()));
605    }
606  }
607
608  C.startFunction(Context::AM_Public,
609                  false,
610                  "void",
611                  "invoke_" + EF->getName(/*Mangle=*/ false),
612                      // We are using un-mangled name since Java
613                      // supports method overloading.
614                  Args);
615
616  if (!EF->hasParam()) {
617    C.indent() << "invoke("RS_EXPORT_FUNC_INDEX_PREFIX << EF->getName() << ");"
618               << std::endl;
619  } else {
620    const RSExportRecordType *ERT = EF->getParamPacketType();
621    std::string FieldPackerName = EF->getName() + "_fp";
622
623    if (genCreateFieldPacker(C, ERT, FieldPackerName.c_str()))
624      genPackVarOfType(C, ERT, NULL, FieldPackerName.c_str());
625
626    C.indent() << "invoke("RS_EXPORT_FUNC_INDEX_PREFIX << EF->getName() << ", "
627               << FieldPackerName << ");" << std::endl;
628  }
629
630  C.endFunction();
631  return;
632}
633
634void RSReflection::genExportForEach(Context &C, const RSExportForEach *EF) {
635  if (EF->isDummyRoot()) {
636    // Skip reflection for dummy root() kernels. Note that we have to
637    // advance the next slot number for ForEach, however.
638    C.indent() << "//private final static int "RS_EXPORT_FOREACH_INDEX_PREFIX
639               << EF->getName() << " = " << C.getNextExportForEachSlot() << ";"
640               << std::endl;
641    return;
642  }
643
644  C.indent() << "private final static int "RS_EXPORT_FOREACH_INDEX_PREFIX
645             << EF->getName() << " = " << C.getNextExportForEachSlot() << ";"
646             << std::endl;
647
648  // forEach_*()
649  Context::ArgTy Args;
650
651  slangAssert(EF->getNumParameters() > 0 || EF->hasReturn());
652
653  if (EF->hasIn())
654    Args.push_back(std::make_pair("Allocation", "ain"));
655  if (EF->hasOut() || EF->hasReturn())
656    Args.push_back(std::make_pair("Allocation", "aout"));
657
658  const RSExportRecordType *ERT = EF->getParamPacketType();
659  if (ERT) {
660    for (RSExportForEach::const_param_iterator I = EF->params_begin(),
661             E = EF->params_end();
662         I != E;
663         I++) {
664      Args.push_back(std::make_pair(GetTypeName((*I)->getType()),
665                                    (*I)->getName()));
666    }
667  }
668
669  const RSExportType *IET = EF->getInType();
670  const RSExportType *OET = EF->getOutType();
671
672  if (mRSContext->getTargetAPI() >= SLANG_JB_MR1_TARGET_API) {
673      int signature = 0;
674      C.startFunction(Context::AM_Public,
675                      false,
676                      "Script.KernelID",
677                      "getKernelID_" + EF->getName(),
678                      0);
679
680      if (IET)
681          signature |= 1;
682      if (OET)
683          signature |= 2;
684
685      //TODO: add element checking
686      C.indent() << "return createKernelID(" << RS_EXPORT_FOREACH_INDEX_PREFIX
687                 << EF->getName() << ", " << signature << ", null, null);"
688                 << std::endl;
689
690      C.endFunction();
691  }
692
693  C.startFunction(Context::AM_Public,
694                  false,
695                  "void",
696                  "forEach_" + EF->getName(),
697                  Args);
698
699  if (IET) {
700    genTypeCheck(C, IET, "ain");
701  }
702  if (OET) {
703    genTypeCheck(C, OET, "aout");
704  }
705
706  if (EF->hasIn() && (EF->hasOut() || EF->hasReturn())) {
707    C.indent() << "// Verify dimensions" << std::endl;
708    C.indent() << "Type tIn = ain.getType();" << std::endl;
709    C.indent() << "Type tOut = aout.getType();" << std::endl;
710    C.indent() << "if ((tIn.getCount() != tOut.getCount()) ||" << std::endl;
711    C.indent() << "    (tIn.getX() != tOut.getX()) ||" << std::endl;
712    C.indent() << "    (tIn.getY() != tOut.getY()) ||" << std::endl;
713    C.indent() << "    (tIn.getZ() != tOut.getZ()) ||" << std::endl;
714    C.indent() << "    (tIn.hasFaces() != tOut.hasFaces()) ||" << std::endl;
715    C.indent() << "    (tIn.hasMipmaps() != tOut.hasMipmaps())) {" << std::endl;
716    C.indent() << "    throw new RSRuntimeException(\"Dimension mismatch "
717               << "between input and output parameters!\");";
718    C.out()    << std::endl;
719    C.indent() << "}" << std::endl;
720  }
721
722  std::string FieldPackerName = EF->getName() + "_fp";
723  if (ERT) {
724    if (genCreateFieldPacker(C, ERT, FieldPackerName.c_str())) {
725      genPackVarOfType(C, ERT, NULL, FieldPackerName.c_str());
726    }
727  }
728  C.indent() << "forEach("RS_EXPORT_FOREACH_INDEX_PREFIX << EF->getName();
729
730  if (EF->hasIn())
731    C.out() << ", ain";
732  else
733    C.out() << ", null";
734
735  if (EF->hasOut() || EF->hasReturn())
736    C.out() << ", aout";
737  else
738    C.out() << ", null";
739
740  if (EF->hasUsrData())
741    C.out() << ", " << FieldPackerName;
742  else
743    C.out() << ", null";
744
745  C.out() << ");" << std::endl;
746
747  C.endFunction();
748  return;
749}
750
751void RSReflection::genTypeInstanceFromPointer(Context &C,
752                                              const RSExportType *ET) {
753  if (ET->getClass() == RSExportType::ExportClassPointer) {
754    // For pointer parameters to original forEach kernels.
755    const RSExportPointerType *EPT =
756        static_cast<const RSExportPointerType*>(ET);
757    genTypeInstance(C, EPT->getPointeeType());
758  } else {
759    // For handling pass-by-value kernel parameters.
760    genTypeInstance(C, ET);
761  }
762}
763
764void RSReflection::genTypeInstance(Context &C,
765                                   const RSExportType *ET) {
766  switch (ET->getClass()) {
767    case RSExportType::ExportClassPrimitive:
768    case RSExportType::ExportClassVector:
769    case RSExportType::ExportClassConstantArray: {
770      std::string TypeName = ET->getElementName();
771      if (C.addTypeNameForElement(TypeName)) {
772        C.indent() << RS_ELEM_PREFIX << TypeName << " = Element." << TypeName
773                   << "(rs);" << std::endl;
774      }
775      break;
776    }
777
778    case RSExportType::ExportClassRecord: {
779      std::string ClassName = ET->getElementName();
780      if (C.addTypeNameForElement(ClassName)) {
781        C.indent() << RS_ELEM_PREFIX << ClassName << " = " << ClassName <<
782                      ".createElement(rs);" << std::endl;
783      }
784      break;
785    }
786
787    default:
788      break;
789  }
790}
791
792void RSReflection::genFieldPackerInstance(Context &C,
793                                          const RSExportType *ET) {
794  switch (ET->getClass()) {
795    case RSExportType::ExportClassPrimitive:
796    case RSExportType::ExportClassVector:
797    case RSExportType::ExportClassConstantArray:
798    case RSExportType::ExportClassRecord: {
799      std::string TypeName = ET->getElementName();
800      C.addTypeNameForFieldPacker(TypeName);
801      break;
802    }
803
804    default:
805      break;
806  }
807}
808
809void RSReflection::genTypeCheck(Context &C,
810                                const RSExportType *ET,
811                                const char *VarName) {
812  C.indent() << "// check " << VarName << std::endl;
813
814  if (ET->getClass() == RSExportType::ExportClassPointer) {
815    const RSExportPointerType *EPT =
816        static_cast<const RSExportPointerType*>(ET);
817    ET = EPT->getPointeeType();
818  }
819
820  std::string TypeName;
821
822  switch (ET->getClass()) {
823    case RSExportType::ExportClassPrimitive:
824    case RSExportType::ExportClassVector:
825    case RSExportType::ExportClassRecord: {
826      TypeName = ET->getElementName();
827      break;
828    }
829
830    default:
831      break;
832  }
833
834  if (!TypeName.empty()) {
835    C.indent() << "if (!" << VarName
836               << ".getType().getElement().isCompatible(" RS_ELEM_PREFIX
837               << TypeName << ")) {" << std::endl;
838    C.indent() << "    throw new RSRuntimeException(\"Type mismatch with "
839               << TypeName << "!\");" << std::endl;
840    C.indent() << "}" << std::endl;
841  }
842
843  return;
844}
845
846
847void RSReflection::genPrimitiveTypeExportVariable(
848    Context &C,
849    const RSExportVar *EV) {
850  slangAssert((EV->getType()->getClass() == RSExportType::ExportClassPrimitive)
851              && "Variable should be type of primitive here");
852
853  const RSExportPrimitiveType *EPT =
854      static_cast<const RSExportPrimitiveType*>(EV->getType());
855  std::string TypeName = GetTypeName(EPT);
856  std::string VarName = EV->getName();
857
858  genPrivateExportVariable(C, TypeName, EV->getName());
859
860  if (EV->isConst()) {
861    C.indent() << "public final static " << TypeName
862               << " " RS_EXPORT_VAR_CONST_PREFIX << VarName << " = ";
863    const clang::APValue &Val = EV->getInit();
864    C.out() << RSReflectionBase::genInitValue(Val, EPT->getType() ==
865        RSExportPrimitiveType::DataTypeBoolean) << ";" << std::endl;
866  } else {
867    // set_*()
868    // This must remain synchronized, since multiple Dalvik threads may
869    // be calling setters.
870    C.startFunction(Context::AM_PublicSynchronized,
871                    false,
872                    "void",
873                    "set_" + VarName,
874                    1,
875                    TypeName.c_str(), "v");
876    if ((EPT->getSize() < 4) || EV->isUnsigned()) {
877      // We create/cache a per-type FieldPacker. This allows us to reuse the
878      // validation logic (for catching negative inputs from Dalvik, as well
879      // as inputs that are too large to be represented in the unsigned type).
880      // Sub-integer types are also handled specially here, so that we don't
881      // overwrite bytes accidentally.
882      std::string ElemName = EPT->getElementName();
883      std::string FPName;
884      FPName = RS_FP_PREFIX + ElemName;
885      C.indent() << "if (" << FPName << "!= null) {"
886                 << std::endl;
887      C.incIndentLevel();
888      C.indent() << FPName << ".reset();" << std::endl;
889      C.decIndentLevel();
890      C.indent() << "} else {" << std::endl;
891      C.incIndentLevel();
892      C.indent() << FPName << " = new FieldPacker("
893                 << EPT->getSize() << ");" << std::endl;
894      C.decIndentLevel();
895      C.indent() << "}" << std::endl;
896
897      genPackVarOfType(C, EPT, "v", FPName.c_str());
898      C.indent() << "setVar("RS_EXPORT_VAR_INDEX_PREFIX << VarName
899                 << ", " << FPName << ");" << std::endl;
900    } else {
901      C.indent() << "setVar("RS_EXPORT_VAR_INDEX_PREFIX << VarName
902                 << ", v);" << std::endl;
903    }
904
905    // Dalvik update comes last, since the input may be invalid (and hence
906    // throw an exception).
907    C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;" << std::endl;
908
909    C.endFunction();
910  }
911
912  genGetExportVariable(C, TypeName, VarName);
913  genGetFieldID(C, VarName);
914  return;
915}
916
917void RSReflection::genPointerTypeExportVariable(Context &C,
918                                                const RSExportVar *EV) {
919  const RSExportType *ET = EV->getType();
920  const RSExportType *PointeeType;
921
922  slangAssert((ET->getClass() == RSExportType::ExportClassPointer) &&
923              "Variable should be type of pointer here");
924
925  PointeeType = static_cast<const RSExportPointerType*>(ET)->getPointeeType();
926  std::string TypeName = GetTypeName(ET);
927  std::string VarName = EV->getName();
928
929  genPrivateExportVariable(C, TypeName, VarName);
930
931  // bind_*()
932  C.startFunction(Context::AM_Public,
933                  false,
934                  "void",
935                  "bind_" + VarName,
936                  1,
937                  TypeName.c_str(), "v");
938
939  C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;" << std::endl;
940  C.indent() << "if (v == null) bindAllocation(null, "RS_EXPORT_VAR_INDEX_PREFIX
941             << VarName << ");" << std::endl;
942
943  if (PointeeType->getClass() == RSExportType::ExportClassRecord)
944    C.indent() << "else bindAllocation(v.getAllocation(), "
945        RS_EXPORT_VAR_INDEX_PREFIX << VarName << ");"
946               << std::endl;
947  else
948    C.indent() << "else bindAllocation(v, "RS_EXPORT_VAR_INDEX_PREFIX
949               << VarName << ");" << std::endl;
950
951  C.endFunction();
952
953  genGetExportVariable(C, TypeName, VarName);
954  return;
955}
956
957void RSReflection::genVectorTypeExportVariable(Context &C,
958                                               const RSExportVar *EV) {
959  slangAssert((EV->getType()->getClass() == RSExportType::ExportClassVector) &&
960              "Variable should be type of vector here");
961
962  std::string TypeName = GetTypeName(EV->getType());
963  std::string VarName = EV->getName();
964
965  genPrivateExportVariable(C, TypeName, VarName);
966  genSetExportVariable(C, TypeName, EV);
967  genGetExportVariable(C, TypeName, VarName);
968  genGetFieldID(C, VarName);
969  return;
970}
971
972void RSReflection::genMatrixTypeExportVariable(Context &C,
973                                               const RSExportVar *EV) {
974  slangAssert((EV->getType()->getClass() == RSExportType::ExportClassMatrix) &&
975              "Variable should be type of matrix here");
976
977    const RSExportType *ET = EV->getType();
978  std::string TypeName = GetTypeName(ET);
979  std::string VarName = EV->getName();
980
981  genPrivateExportVariable(C, TypeName, VarName);
982
983  // set_*()
984  if (!EV->isConst()) {
985    const char *FieldPackerName = "fp";
986    C.startFunction(Context::AM_PublicSynchronized,
987                    false,
988                    "void",
989                    "set_" + VarName,
990                    1,
991                    TypeName.c_str(), "v");
992    C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;" << std::endl;
993
994    if (genCreateFieldPacker(C, ET, FieldPackerName))
995      genPackVarOfType(C, ET, "v", FieldPackerName);
996    C.indent() << "setVar("RS_EXPORT_VAR_INDEX_PREFIX << VarName << ", "
997               << FieldPackerName << ");" << std::endl;
998
999    C.endFunction();
1000  }
1001
1002  genGetExportVariable(C, TypeName, VarName);
1003  genGetFieldID(C, VarName);
1004  return;
1005}
1006
1007void RSReflection::genConstantArrayTypeExportVariable(
1008    Context &C,
1009    const RSExportVar *EV) {
1010  slangAssert((EV->getType()->getClass() ==
1011               RSExportType::ExportClassConstantArray) &&
1012              "Variable should be type of constant array here");
1013
1014  std::string TypeName = GetTypeName(EV->getType());
1015  std::string VarName = EV->getName();
1016
1017  genPrivateExportVariable(C, TypeName, VarName);
1018  genSetExportVariable(C, TypeName, EV);
1019  genGetExportVariable(C, TypeName, VarName);
1020  genGetFieldID(C, VarName);
1021  return;
1022}
1023
1024void RSReflection::genRecordTypeExportVariable(Context &C,
1025                                               const RSExportVar *EV) {
1026  slangAssert((EV->getType()->getClass() == RSExportType::ExportClassRecord) &&
1027              "Variable should be type of struct here");
1028
1029  std::string TypeName = GetTypeName(EV->getType());
1030  std::string VarName = EV->getName();
1031
1032  genPrivateExportVariable(C, TypeName, VarName);
1033  genSetExportVariable(C, TypeName, EV);
1034  genGetExportVariable(C, TypeName, VarName);
1035  genGetFieldID(C, VarName);
1036  return;
1037}
1038
1039void RSReflection::genPrivateExportVariable(Context &C,
1040                                            const std::string &TypeName,
1041                                            const std::string &VarName) {
1042  C.indent() << "private " << TypeName << " "RS_EXPORT_VAR_PREFIX
1043             << VarName << ";" << std::endl;
1044  return;
1045}
1046
1047void RSReflection::genSetExportVariable(Context &C,
1048                                        const std::string &TypeName,
1049                                        const RSExportVar *EV) {
1050  if (!EV->isConst()) {
1051    const char *FieldPackerName = "fp";
1052    std::string VarName = EV->getName();
1053    const RSExportType *ET = EV->getType();
1054    C.startFunction(Context::AM_PublicSynchronized,
1055                    false,
1056                    "void",
1057                    "set_" + VarName,
1058                    1,
1059                    TypeName.c_str(), "v");
1060    C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;" << std::endl;
1061
1062    if (genCreateFieldPacker(C, ET, FieldPackerName))
1063      genPackVarOfType(C, ET, "v", FieldPackerName);
1064
1065    if (mRSContext->getTargetAPI() < SLANG_JB_TARGET_API) {
1066      // Legacy apps must use the old setVar() without Element/dim components.
1067      C.indent() << "setVar("RS_EXPORT_VAR_INDEX_PREFIX << VarName
1068                 << ", " << FieldPackerName << ");" << std::endl;
1069    } else {
1070      // We only have support for one-dimensional array reflection today,
1071      // but the entry point (i.e. setVar()) takes an array of dimensions.
1072      C.indent() << "int []__dimArr = new int[1];" << std::endl;
1073      C.indent() << "__dimArr[0] = " << ET->getSize() << ";" << std::endl;
1074      C.indent() << "setVar("RS_EXPORT_VAR_INDEX_PREFIX << VarName << ", "
1075                 << FieldPackerName << ", " RS_ELEM_PREFIX
1076                 << ET->getElementName() << ", __dimArr);" << std::endl;
1077    }
1078
1079    C.endFunction();
1080  }
1081  return;
1082}
1083
1084void RSReflection::genGetExportVariable(Context &C,
1085                                        const std::string &TypeName,
1086                                        const std::string &VarName) {
1087  C.startFunction(Context::AM_Public,
1088                  false,
1089                  TypeName.c_str(),
1090                  "get_" + VarName,
1091                  0);
1092
1093  C.indent() << "return "RS_EXPORT_VAR_PREFIX << VarName << ";" << std::endl;
1094
1095  C.endFunction();
1096}
1097
1098void RSReflection::genGetFieldID(Context &C, const std::string &VarName) {
1099  // We only generate getFieldID_*() for non-Pointer (bind) types.
1100  if (mRSContext->getTargetAPI() >= SLANG_JB_MR1_TARGET_API) {
1101    C.startFunction(Context::AM_Public,
1102                    false,
1103                    "Script.FieldID",
1104                    "getFieldID_" + VarName,
1105                    0);
1106
1107    C.indent() << "return createFieldID(" << RS_EXPORT_VAR_INDEX_PREFIX
1108               << VarName << ", null);" << std::endl;
1109
1110    C.endFunction();
1111  }
1112}
1113
1114/******************* Methods to generate script class /end *******************/
1115
1116bool RSReflection::genCreateFieldPacker(Context &C,
1117                                        const RSExportType *ET,
1118                                        const char *FieldPackerName) {
1119  size_t AllocSize = RSExportType::GetTypeAllocSize(ET);
1120  if (AllocSize > 0)
1121    C.indent() << "FieldPacker " << FieldPackerName << " = new FieldPacker("
1122               << AllocSize << ");" << std::endl;
1123  else
1124    return false;
1125  return true;
1126}
1127
1128void RSReflection::genPackVarOfType(Context &C,
1129                                    const RSExportType *ET,
1130                                    const char *VarName,
1131                                    const char *FieldPackerName) {
1132  switch (ET->getClass()) {
1133    case RSExportType::ExportClassPrimitive:
1134    case RSExportType::ExportClassVector: {
1135      C.indent() << FieldPackerName << "."
1136                 << GetPackerAPIName(
1137                     static_cast<const RSExportPrimitiveType*>(ET))
1138                 << "(" << VarName << ");" << std::endl;
1139      break;
1140    }
1141    case RSExportType::ExportClassPointer: {
1142      // Must reflect as type Allocation in Java
1143      const RSExportType *PointeeType =
1144          static_cast<const RSExportPointerType*>(ET)->getPointeeType();
1145
1146      if (PointeeType->getClass() != RSExportType::ExportClassRecord)
1147        C.indent() << FieldPackerName << ".addI32(" << VarName
1148                   << ".getPtr());" << std::endl;
1149      else
1150        C.indent() << FieldPackerName << ".addI32(" << VarName
1151                   << ".getAllocation().getPtr());" << std::endl;
1152      break;
1153    }
1154    case RSExportType::ExportClassMatrix: {
1155      C.indent() << FieldPackerName << ".addMatrix(" << VarName << ");"
1156                 << std::endl;
1157      break;
1158    }
1159    case RSExportType::ExportClassConstantArray: {
1160      const RSExportConstantArrayType *ECAT =
1161          static_cast<const RSExportConstantArrayType *>(ET);
1162
1163      // TODO(zonr): more elegant way. Currently, we obtain the unique index
1164      //             variable (this method involves recursive call which means
1165      //             we may have more than one level loop, therefore we can't
1166      //             always use the same index variable name here) name given
1167      //             in the for-loop from counting the '.' in @VarName.
1168      unsigned Level = 0;
1169      size_t LastDotPos = 0;
1170      std::string ElementVarName(VarName);
1171
1172      while (LastDotPos != std::string::npos) {
1173        LastDotPos = ElementVarName.find_first_of('.', LastDotPos + 1);
1174        Level++;
1175      }
1176      std::string IndexVarName("ct");
1177      IndexVarName.append(llvm::utostr_32(Level));
1178
1179      C.indent() << "for (int " << IndexVarName << " = 0; " <<
1180                          IndexVarName << " < " << ECAT->getSize() << "; " <<
1181                          IndexVarName << "++)";
1182      C.startBlock();
1183
1184      ElementVarName.append("[" + IndexVarName + "]");
1185      genPackVarOfType(C, ECAT->getElementType(), ElementVarName.c_str(),
1186                       FieldPackerName);
1187
1188      C.endBlock();
1189      break;
1190    }
1191    case RSExportType::ExportClassRecord: {
1192      const RSExportRecordType *ERT =
1193          static_cast<const RSExportRecordType*>(ET);
1194      // Relative pos from now on in field packer
1195      unsigned Pos = 0;
1196
1197      for (RSExportRecordType::const_field_iterator I = ERT->fields_begin(),
1198               E = ERT->fields_end();
1199           I != E;
1200           I++) {
1201        const RSExportRecordType::Field *F = *I;
1202        std::string FieldName;
1203        size_t FieldOffset = F->getOffsetInParent();
1204        size_t FieldStoreSize = RSExportType::GetTypeStoreSize(F->getType());
1205        size_t FieldAllocSize = RSExportType::GetTypeAllocSize(F->getType());
1206
1207        if (VarName != NULL)
1208          FieldName = VarName + ("." + F->getName());
1209        else
1210          FieldName = F->getName();
1211
1212        if (FieldOffset > Pos)
1213          C.indent() << FieldPackerName << ".skip("
1214                     << (FieldOffset - Pos) << ");" << std::endl;
1215
1216        genPackVarOfType(C, F->getType(), FieldName.c_str(), FieldPackerName);
1217
1218        // There is padding in the field type
1219        if (FieldAllocSize > FieldStoreSize)
1220            C.indent() << FieldPackerName << ".skip("
1221                       << (FieldAllocSize - FieldStoreSize)
1222                       << ");" << std::endl;
1223
1224        Pos = FieldOffset + FieldAllocSize;
1225      }
1226
1227      // There maybe some padding after the struct
1228      if (RSExportType::GetTypeAllocSize(ERT) > Pos)
1229        C.indent() << FieldPackerName << ".skip("
1230                   << RSExportType::GetTypeAllocSize(ERT) - Pos << ");"
1231                   << std::endl;
1232      break;
1233    }
1234    default: {
1235      slangAssert(false && "Unknown class of type");
1236    }
1237  }
1238
1239  return;
1240}
1241
1242void RSReflection::genAllocateVarOfType(Context &C,
1243                                        const RSExportType *T,
1244                                        const std::string &VarName) {
1245  switch (T->getClass()) {
1246    case RSExportType::ExportClassPrimitive: {
1247      // Primitive type like int in Java has its own storage once it's declared.
1248      //
1249      // FIXME: Should we allocate storage for RS object?
1250      // if (static_cast<const RSExportPrimitiveType *>(T)->isRSObjectType())
1251      //  C.indent() << VarName << " = new " << GetTypeName(T) << "();"
1252      //             << std::endl;
1253      break;
1254    }
1255    case RSExportType::ExportClassPointer: {
1256      // Pointer type is an instance of Allocation or a TypeClass whose value is
1257      // expected to be assigned by programmer later in Java program. Therefore
1258      // we don't reflect things like [VarName] = new Allocation();
1259      C.indent() << VarName << " = null;" << std::endl;
1260      break;
1261    }
1262    case RSExportType::ExportClassConstantArray: {
1263      const RSExportConstantArrayType *ECAT =
1264          static_cast<const RSExportConstantArrayType *>(T);
1265      const RSExportType *ElementType = ECAT->getElementType();
1266
1267      C.indent() << VarName << " = new " << GetTypeName(ElementType)
1268                 << "[" << ECAT->getSize() << "];" << std::endl;
1269
1270      // Primitive type element doesn't need allocation code.
1271      if (ElementType->getClass() != RSExportType::ExportClassPrimitive) {
1272        C.indent() << "for (int $ct = 0; $ct < " << ECAT->getSize() << "; "
1273                            "$ct++)";
1274        C.startBlock();
1275
1276        std::string ElementVarName(VarName);
1277        ElementVarName.append("[$ct]");
1278        genAllocateVarOfType(C, ElementType, ElementVarName);
1279
1280        C.endBlock();
1281      }
1282      break;
1283    }
1284    case RSExportType::ExportClassVector:
1285    case RSExportType::ExportClassMatrix:
1286    case RSExportType::ExportClassRecord: {
1287      C.indent() << VarName << " = new " << GetTypeName(T) << "();"
1288                 << std::endl;
1289      break;
1290    }
1291  }
1292  return;
1293}
1294
1295void RSReflection::genNewItemBufferIfNull(Context &C,
1296                                          const char *Index) {
1297  C.indent() << "if (" RS_TYPE_ITEM_BUFFER_NAME " == null) "
1298                  RS_TYPE_ITEM_BUFFER_NAME " = "
1299                    "new " RS_TYPE_ITEM_CLASS_NAME
1300                      "[getType().getX() /* count */];"
1301             << std::endl;
1302  if (Index != NULL)
1303    C.indent() << "if ("RS_TYPE_ITEM_BUFFER_NAME"[" << Index << "] == null) "
1304                    RS_TYPE_ITEM_BUFFER_NAME"[" << Index << "] = "
1305                      "new "RS_TYPE_ITEM_CLASS_NAME"();" << std::endl;
1306  return;
1307}
1308
1309void RSReflection::genNewItemBufferPackerIfNull(Context &C) {
1310  C.indent() << "if (" RS_TYPE_ITEM_BUFFER_PACKER_NAME " == null) "
1311                  RS_TYPE_ITEM_BUFFER_PACKER_NAME " = "
1312                    "new FieldPacker(" RS_TYPE_ITEM_CLASS_NAME
1313                      ".sizeof * getType().getX()/* count */"
1314                        ");" << std::endl;
1315  return;
1316}
1317
1318/********************** Methods to generate type class  **********************/
1319bool RSReflection::genTypeClass(Context &C,
1320                                const RSExportRecordType *ERT,
1321                                std::string &ErrorMsg) {
1322  std::string ClassName = ERT->getElementName();
1323  std::string superClassName = C.getRSPackageName();
1324  superClassName += RS_TYPE_CLASS_SUPER_CLASS_NAME;
1325
1326  if (!C.startClass(Context::AM_Public,
1327                    false,
1328                    ClassName,
1329                    superClassName.c_str(),
1330                    ErrorMsg))
1331    return false;
1332
1333  mGeneratedFileNames->push_back(ClassName);
1334
1335  genTypeItemClass(C, ERT);
1336
1337  // Declare item buffer and item buffer packer
1338  C.indent() << "private "RS_TYPE_ITEM_CLASS_NAME" "RS_TYPE_ITEM_BUFFER_NAME"[]"
1339      ";" << std::endl;
1340  C.indent() << "private FieldPacker "RS_TYPE_ITEM_BUFFER_PACKER_NAME";"
1341             << std::endl;
1342  C.indent() << "private static java.lang.ref.WeakReference<Element> "
1343             RS_TYPE_ELEMENT_REF_NAME
1344             " = new java.lang.ref.WeakReference<Element>(null);" << std::endl;
1345
1346  genTypeClassConstructor(C, ERT);
1347  genTypeClassCopyToArrayLocal(C, ERT);
1348  genTypeClassCopyToArray(C, ERT);
1349  genTypeClassItemSetter(C, ERT);
1350  genTypeClassItemGetter(C, ERT);
1351  genTypeClassComponentSetter(C, ERT);
1352  genTypeClassComponentGetter(C, ERT);
1353  genTypeClassCopyAll(C, ERT);
1354  if (!mRSContext->isCompatLib()) {
1355    // Skip the resize method if we are targeting a compatibility library.
1356    genTypeClassResize(C);
1357  }
1358
1359  C.endClass();
1360
1361  C.resetFieldIndex();
1362  C.clearFieldIndexMap();
1363
1364  return true;
1365}
1366
1367void RSReflection::genTypeItemClass(Context &C,
1368                                    const RSExportRecordType *ERT) {
1369  C.indent() << "static public class "RS_TYPE_ITEM_CLASS_NAME;
1370  C.startBlock();
1371
1372  C.indent() << "public static final int sizeof = "
1373             << RSExportType::GetTypeAllocSize(ERT) << ";" << std::endl;
1374
1375  // Member elements
1376  C.out() << std::endl;
1377  for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(),
1378           FE = ERT->fields_end();
1379       FI != FE;
1380       FI++) {
1381    C.indent() << GetTypeName((*FI)->getType()) << " " << (*FI)->getName()
1382               << ";" << std::endl;
1383  }
1384
1385  // Constructor
1386  C.out() << std::endl;
1387  C.indent() << RS_TYPE_ITEM_CLASS_NAME"()";
1388  C.startBlock();
1389
1390  for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(),
1391           FE = ERT->fields_end();
1392       FI != FE;
1393       FI++) {
1394    const RSExportRecordType::Field *F = *FI;
1395    genAllocateVarOfType(C, F->getType(), F->getName());
1396  }
1397
1398  // end Constructor
1399  C.endBlock();
1400
1401  // end Item class
1402  C.endBlock();
1403
1404  return;
1405}
1406
1407void RSReflection::genTypeClassConstructor(Context &C,
1408                                           const RSExportRecordType *ERT) {
1409  const char *RenderScriptVar = "rs";
1410
1411  C.startFunction(Context::AM_Public,
1412                  true,
1413                  "Element",
1414                  "createElement",
1415                  1,
1416                  "RenderScript", RenderScriptVar);
1417
1418  // TODO(all): Fix weak-refs + multi-context issue.
1419  // C.indent() << "Element e = " << RS_TYPE_ELEMENT_REF_NAME
1420  //            << ".get();" << std::endl;
1421  // C.indent() << "if (e != null) return e;" << std::endl;
1422  genBuildElement(C, "eb", ERT, RenderScriptVar, /* IsInline = */true);
1423  C.indent() << "return eb.create();" << std::endl;
1424  // C.indent() << "e = eb.create();" << std::endl;
1425  // C.indent() << RS_TYPE_ELEMENT_REF_NAME
1426  //            << " = new java.lang.ref.WeakReference<Element>(e);"
1427  //            << std::endl;
1428  // C.indent() << "return e;" << std::endl;
1429  C.endFunction();
1430
1431
1432  // private with element
1433  C.startFunction(Context::AM_Private,
1434                  false,
1435                  NULL,
1436                  C.getClassName(),
1437                  1,
1438                  "RenderScript", RenderScriptVar);
1439  C.indent() << RS_TYPE_ITEM_BUFFER_NAME" = null;" << std::endl;
1440  C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME" = null;" << std::endl;
1441  C.indent() << "mElement = createElement(" << RenderScriptVar << ");"
1442             << std::endl;
1443  C.endFunction();
1444
1445  // 1D without usage
1446  C.startFunction(Context::AM_Public,
1447                  false,
1448                  NULL,
1449                  C.getClassName(),
1450                  2,
1451                  "RenderScript", RenderScriptVar,
1452                  "int", "count");
1453
1454  C.indent() << RS_TYPE_ITEM_BUFFER_NAME" = null;" << std::endl;
1455  C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME" = null;" << std::endl;
1456  C.indent() << "mElement = createElement(" << RenderScriptVar << ");"
1457             << std::endl;
1458  // Call init() in super class
1459  C.indent() << "init(" << RenderScriptVar << ", count);" << std::endl;
1460  C.endFunction();
1461
1462  // 1D with usage
1463  C.startFunction(Context::AM_Public,
1464                  false,
1465                  NULL,
1466                  C.getClassName(),
1467                  3,
1468                  "RenderScript", RenderScriptVar,
1469                  "int", "count",
1470                  "int", "usages");
1471
1472  C.indent() << RS_TYPE_ITEM_BUFFER_NAME" = null;" << std::endl;
1473  C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME" = null;" << std::endl;
1474  C.indent() << "mElement = createElement(" << RenderScriptVar << ");"
1475             << std::endl;
1476  // Call init() in super class
1477  C.indent() << "init(" << RenderScriptVar << ", count, usages);" << std::endl;
1478  C.endFunction();
1479
1480
1481  // create1D with usage
1482  C.startFunction(Context::AM_Public,
1483                  true,
1484                  C.getClassName().c_str(),
1485                  "create1D",
1486                  3,
1487                  "RenderScript", RenderScriptVar,
1488                  "int", "dimX",
1489                  "int", "usages");
1490  C.indent() << C.getClassName() << " obj = new " << C.getClassName() << "("
1491             << RenderScriptVar << ");" << std::endl;
1492  C.indent() << "obj.mAllocation = Allocation.createSized("
1493                "rs, obj.mElement, dimX, usages);" << std::endl;
1494  C.indent() << "return obj;" << std::endl;
1495  C.endFunction();
1496
1497  // create1D without usage
1498  C.startFunction(Context::AM_Public,
1499                  true,
1500                  C.getClassName().c_str(),
1501                  "create1D",
1502                  2,
1503                  "RenderScript", RenderScriptVar,
1504                  "int", "dimX");
1505  C.indent() << "return create1D(" << RenderScriptVar
1506             << ", dimX, Allocation.USAGE_SCRIPT);" << std::endl;
1507  C.endFunction();
1508
1509
1510  // create2D without usage
1511  C.startFunction(Context::AM_Public,
1512                  true,
1513                  C.getClassName().c_str(),
1514                  "create2D",
1515                  3,
1516                  "RenderScript", RenderScriptVar,
1517                  "int", "dimX",
1518                  "int", "dimY");
1519  C.indent() << "return create2D(" << RenderScriptVar
1520             << ", dimX, dimY, Allocation.USAGE_SCRIPT);" << std::endl;
1521  C.endFunction();
1522
1523  // create2D with usage
1524  C.startFunction(Context::AM_Public,
1525                  true,
1526                  C.getClassName().c_str(),
1527                  "create2D",
1528                  4,
1529                  "RenderScript", RenderScriptVar,
1530                  "int", "dimX",
1531                  "int", "dimY",
1532                  "int", "usages");
1533
1534  C.indent() << C.getClassName() << " obj = new " << C.getClassName() << "("
1535             << RenderScriptVar << ");" << std::endl;
1536  C.indent() << "Type.Builder b = new Type.Builder(rs, obj.mElement);"
1537             << std::endl;
1538  C.indent() << "b.setX(dimX);" << std::endl;
1539  C.indent() << "b.setY(dimY);" << std::endl;
1540  C.indent() << "Type t = b.create();" << std::endl;
1541  C.indent() << "obj.mAllocation = Allocation.createTyped(rs, t, usages);"
1542             << std::endl;
1543  C.indent() << "return obj;" << std::endl;
1544  C.endFunction();
1545
1546
1547  // createTypeBuilder
1548  C.startFunction(Context::AM_Public,
1549                  true,
1550                  "Type.Builder",
1551                  "createTypeBuilder",
1552                  1,
1553                  "RenderScript", RenderScriptVar);
1554  C.indent() << "Element e = createElement(" << RenderScriptVar << ");"
1555             << std::endl;
1556  C.indent() << "return new Type.Builder(rs, e);" << std::endl;
1557  C.endFunction();
1558
1559  // createCustom with usage
1560  C.startFunction(Context::AM_Public,
1561                  true,
1562                  C.getClassName().c_str(),
1563                  "createCustom",
1564                  3,
1565                  "RenderScript", RenderScriptVar,
1566                  "Type.Builder", "tb",
1567                  "int", "usages");
1568  C.indent() << C.getClassName() << " obj = new " << C.getClassName() << "("
1569             << RenderScriptVar << ");" << std::endl;
1570  C.indent() << "Type t = tb.create();" << std::endl;
1571  C.indent() << "if (t.getElement() != obj.mElement) {" << std::endl;
1572  C.indent() << "    throw new RSIllegalArgumentException("
1573                "\"Type.Builder did not match expected element type.\");"
1574             << std::endl;
1575  C.indent() << "}" << std::endl;
1576  C.indent() << "obj.mAllocation = Allocation.createTyped(rs, t, usages);"
1577             << std::endl;
1578  C.indent() << "return obj;" << std::endl;
1579  C.endFunction();
1580}
1581
1582
1583void RSReflection::genTypeClassCopyToArray(Context &C,
1584                                           const RSExportRecordType *ERT) {
1585  C.startFunction(Context::AM_Private,
1586                  false,
1587                  "void",
1588                  "copyToArray",
1589                  2,
1590                  RS_TYPE_ITEM_CLASS_NAME, "i",
1591                  "int", "index");
1592
1593  genNewItemBufferPackerIfNull(C);
1594  C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME
1595                ".reset(index * "RS_TYPE_ITEM_CLASS_NAME".sizeof);"
1596             << std::endl;
1597
1598  C.indent() << "copyToArrayLocal(i, " RS_TYPE_ITEM_BUFFER_PACKER_NAME
1599                ");" << std::endl;
1600
1601  C.endFunction();
1602  return;
1603}
1604
1605void RSReflection::genTypeClassCopyToArrayLocal(Context &C,
1606                                                const RSExportRecordType *ERT) {
1607  C.startFunction(Context::AM_Private,
1608                  false,
1609                  "void",
1610                  "copyToArrayLocal",
1611                  2,
1612                  RS_TYPE_ITEM_CLASS_NAME, "i",
1613                  "FieldPacker", "fp");
1614
1615  genPackVarOfType(C, ERT, "i", "fp");
1616
1617  C.endFunction();
1618  return;
1619}
1620
1621void RSReflection::genTypeClassItemSetter(Context &C,
1622                                          const RSExportRecordType *ERT) {
1623  C.startFunction(Context::AM_PublicSynchronized,
1624                  false,
1625                  "void",
1626                  "set",
1627                  3,
1628                  RS_TYPE_ITEM_CLASS_NAME, "i",
1629                  "int", "index",
1630                  "boolean", "copyNow");
1631  genNewItemBufferIfNull(C, NULL);
1632  C.indent() << RS_TYPE_ITEM_BUFFER_NAME"[index] = i;" << std::endl;
1633
1634  C.indent() << "if (copyNow) ";
1635  C.startBlock();
1636
1637  C.indent() << "copyToArray(i, index);" << std::endl;
1638  C.indent() << "FieldPacker fp = new FieldPacker(" RS_TYPE_ITEM_CLASS_NAME
1639                ".sizeof);" << std::endl;
1640  C.indent() << "copyToArrayLocal(i, fp);" << std::endl;
1641  C.indent() << "mAllocation.setFromFieldPacker(index, fp);" << std::endl;
1642
1643  // End of if (copyNow)
1644  C.endBlock();
1645
1646  C.endFunction();
1647  return;
1648}
1649
1650void RSReflection::genTypeClassItemGetter(Context &C,
1651                                          const RSExportRecordType *ERT) {
1652  C.startFunction(Context::AM_PublicSynchronized,
1653                  false,
1654                  RS_TYPE_ITEM_CLASS_NAME,
1655                  "get",
1656                  1,
1657                  "int", "index");
1658  C.indent() << "if ("RS_TYPE_ITEM_BUFFER_NAME" == null) return null;"
1659             << std::endl;
1660  C.indent() << "return "RS_TYPE_ITEM_BUFFER_NAME"[index];" << std::endl;
1661  C.endFunction();
1662  return;
1663}
1664
1665void RSReflection::genTypeClassComponentSetter(Context &C,
1666                                               const RSExportRecordType *ERT) {
1667  for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(),
1668           FE = ERT->fields_end();
1669       FI != FE;
1670       FI++) {
1671    const RSExportRecordType::Field *F = *FI;
1672    size_t FieldOffset = F->getOffsetInParent();
1673    size_t FieldStoreSize = RSExportType::GetTypeStoreSize(F->getType());
1674    unsigned FieldIndex = C.getFieldIndex(F);
1675
1676    C.startFunction(Context::AM_PublicSynchronized,
1677                    false,
1678                    "void",
1679                    "set_" + F->getName(), 3,
1680                    "int", "index",
1681                    GetTypeName(F->getType()).c_str(), "v",
1682                    "boolean", "copyNow");
1683    genNewItemBufferPackerIfNull(C);
1684    genNewItemBufferIfNull(C, "index");
1685    C.indent() << RS_TYPE_ITEM_BUFFER_NAME"[index]." << F->getName()
1686               << " = v;" << std::endl;
1687
1688    C.indent() << "if (copyNow) ";
1689    C.startBlock();
1690
1691    if (FieldOffset > 0)
1692      C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME
1693                    ".reset(index * "RS_TYPE_ITEM_CLASS_NAME".sizeof + "
1694                 << FieldOffset << ");" << std::endl;
1695    else
1696      C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME
1697                    ".reset(index * "RS_TYPE_ITEM_CLASS_NAME".sizeof);"
1698                 << std::endl;
1699    genPackVarOfType(C, F->getType(), "v", RS_TYPE_ITEM_BUFFER_PACKER_NAME);
1700
1701    C.indent() << "FieldPacker fp = new FieldPacker(" << FieldStoreSize << ");"
1702               << std::endl;
1703    genPackVarOfType(C, F->getType(), "v", "fp");
1704    C.indent() << "mAllocation.setFromFieldPacker(index, " << FieldIndex
1705               << ", fp);"
1706               << std::endl;
1707
1708    // End of if (copyNow)
1709    C.endBlock();
1710
1711    C.endFunction();
1712  }
1713  return;
1714}
1715
1716void RSReflection::genTypeClassComponentGetter(Context &C,
1717                                               const RSExportRecordType *ERT) {
1718  for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(),
1719           FE = ERT->fields_end();
1720       FI != FE;
1721       FI++) {
1722    const RSExportRecordType::Field *F = *FI;
1723    C.startFunction(Context::AM_PublicSynchronized,
1724                    false,
1725                    GetTypeName(F->getType()).c_str(),
1726                    "get_" + F->getName(),
1727                    1,
1728                    "int", "index");
1729    C.indent() << "if ("RS_TYPE_ITEM_BUFFER_NAME" == null) return "
1730               << GetTypeNullValue(F->getType()) << ";" << std::endl;
1731    C.indent() << "return "RS_TYPE_ITEM_BUFFER_NAME"[index]." << F->getName()
1732               << ";" << std::endl;
1733    C.endFunction();
1734  }
1735  return;
1736}
1737
1738void RSReflection::genTypeClassCopyAll(Context &C,
1739                                       const RSExportRecordType *ERT) {
1740  C.startFunction(Context::AM_PublicSynchronized, false, "void", "copyAll", 0);
1741
1742  C.indent() << "for (int ct = 0; ct < "RS_TYPE_ITEM_BUFFER_NAME".length; ct++)"
1743                  " copyToArray("RS_TYPE_ITEM_BUFFER_NAME"[ct], ct);"
1744             << std::endl;
1745  C.indent() << "mAllocation.setFromFieldPacker(0, "
1746                  RS_TYPE_ITEM_BUFFER_PACKER_NAME");"
1747             << std::endl;
1748
1749  C.endFunction();
1750  return;
1751}
1752
1753void RSReflection::genTypeClassResize(Context &C) {
1754  C.startFunction(Context::AM_PublicSynchronized,
1755                  false,
1756                  "void",
1757                  "resize",
1758                  1,
1759                  "int", "newSize");
1760
1761  C.indent() << "if (mItemArray != null) ";
1762  C.startBlock();
1763  C.indent() << "int oldSize = mItemArray.length;" << std::endl;
1764  C.indent() << "int copySize = Math.min(oldSize, newSize);" << std::endl;
1765  C.indent() << "if (newSize == oldSize) return;" << std::endl;
1766  C.indent() << "Item ni[] = new Item[newSize];" << std::endl;
1767  C.indent() << "System.arraycopy(mItemArray, 0, ni, 0, copySize);"
1768             << std::endl;
1769  C.indent() << "mItemArray = ni;" << std::endl;
1770  C.endBlock();
1771  C.indent() << "mAllocation.resize(newSize);" << std::endl;
1772
1773  C.indent() << "if (" RS_TYPE_ITEM_BUFFER_PACKER_NAME " != null) "
1774                  RS_TYPE_ITEM_BUFFER_PACKER_NAME " = "
1775                    "new FieldPacker(" RS_TYPE_ITEM_CLASS_NAME
1776                      ".sizeof * getType().getX()/* count */"
1777                        ");" << std::endl;
1778
1779  C.endFunction();
1780  return;
1781}
1782
1783/******************** Methods to generate type class /end ********************/
1784
1785/********** Methods to create Element in Java of given record type ***********/
1786void RSReflection::genBuildElement(Context &C,
1787                                   const char *ElementBuilderName,
1788                                   const RSExportRecordType *ERT,
1789                                   const char *RenderScriptVar,
1790                                   bool IsInline) {
1791  C.indent() << "Element.Builder " << ElementBuilderName << " = "
1792      "new Element.Builder(" << RenderScriptVar << ");" << std::endl;
1793
1794  // eb.add(...)
1795  genAddElementToElementBuilder(C,
1796                                ERT,
1797                                "",
1798                                ElementBuilderName,
1799                                RenderScriptVar,
1800                                /* ArraySize = */0);
1801
1802  if (!IsInline)
1803    C.indent() << "return " << ElementBuilderName << ".create();" << std::endl;
1804  return;
1805}
1806
1807#define EB_ADD(x) do {                                              \
1808  C.indent() << ElementBuilderName                                  \
1809             << ".add(" << x << ", \"" << VarName << "\"";  \
1810  if (ArraySize > 0)                                                \
1811    C.out() << ", " << ArraySize;                                   \
1812  C.out() << ");" << std::endl;                                     \
1813  C.incFieldIndex();                                                \
1814} while (false)
1815
1816void RSReflection::genAddElementToElementBuilder(Context &C,
1817                                                 const RSExportType *ET,
1818                                                 const std::string &VarName,
1819                                                 const char *ElementBuilderName,
1820                                                 const char *RenderScriptVar,
1821                                                 unsigned ArraySize) {
1822  std::string ElementConstruct = GetBuiltinElementConstruct(ET);
1823
1824  if (ElementConstruct != "") {
1825    EB_ADD(ElementConstruct << "(" << RenderScriptVar << ")");
1826  } else {
1827    if ((ET->getClass() == RSExportType::ExportClassPrimitive) ||
1828        (ET->getClass() == RSExportType::ExportClassVector)) {
1829      const RSExportPrimitiveType *EPT =
1830          static_cast<const RSExportPrimitiveType*>(ET);
1831      const char *DataTypeName =
1832          RSExportPrimitiveType::getRSReflectionType(EPT)->rs_type;
1833      int Size = (ET->getClass() == RSExportType::ExportClassVector) ?
1834          static_cast<const RSExportVectorType*>(ET)->getNumElement() :
1835          1;
1836
1837      if (EPT->getClass() == RSExportType::ExportClassPrimitive) {
1838        // Element.createUser()
1839        EB_ADD("Element.createUser(" << RenderScriptVar
1840                                     << ", Element.DataType."
1841                                     << DataTypeName << ")");
1842      } else {
1843        slangAssert((ET->getClass() == RSExportType::ExportClassVector) &&
1844                    "Unexpected type.");
1845        EB_ADD("Element.createVector(" << RenderScriptVar
1846                                       << ", Element.DataType."
1847                                       << DataTypeName << ", "
1848                                       << Size << ")");
1849      }
1850#ifndef NDEBUG
1851    } else if (ET->getClass() == RSExportType::ExportClassPointer) {
1852      // Pointer type variable should be resolved in
1853      // GetBuiltinElementConstruct()
1854      slangAssert(false && "??");
1855    } else if (ET->getClass() == RSExportType::ExportClassMatrix) {
1856      // Matrix type variable should be resolved
1857      // in GetBuiltinElementConstruct()
1858      slangAssert(false && "??");
1859#endif
1860    } else if (ET->getClass() == RSExportType::ExportClassConstantArray) {
1861      const RSExportConstantArrayType *ECAT =
1862          static_cast<const RSExportConstantArrayType *>(ET);
1863
1864      const RSExportType *ElementType = ECAT->getElementType();
1865      if (ElementType->getClass() != RSExportType::ExportClassRecord) {
1866        genAddElementToElementBuilder(C,
1867                                      ECAT->getElementType(),
1868                                      VarName,
1869                                      ElementBuilderName,
1870                                      RenderScriptVar,
1871                                      ECAT->getSize());
1872      } else {
1873        std::string NewElementBuilderName(ElementBuilderName);
1874        NewElementBuilderName.append(1, '_');
1875
1876        genBuildElement(C,
1877                        NewElementBuilderName.c_str(),
1878                        static_cast<const RSExportRecordType*>(ElementType),
1879                        RenderScriptVar,
1880                        /* IsInline = */true);
1881        ArraySize = ECAT->getSize();
1882        EB_ADD(NewElementBuilderName << ".create()");
1883      }
1884    } else if (ET->getClass() == RSExportType::ExportClassRecord) {
1885      // Simalar to case of RSExportType::ExportClassRecord in genPackVarOfType.
1886      //
1887      // TODO(zonr): Generalize these two function such that there's no
1888      //             duplicated codes.
1889      const RSExportRecordType *ERT =
1890          static_cast<const RSExportRecordType*>(ET);
1891      int Pos = 0;    // relative pos from now on
1892
1893      for (RSExportRecordType::const_field_iterator I = ERT->fields_begin(),
1894               E = ERT->fields_end();
1895           I != E;
1896           I++) {
1897        const RSExportRecordType::Field *F = *I;
1898        std::string FieldName;
1899        int FieldOffset = F->getOffsetInParent();
1900        int FieldStoreSize = RSExportType::GetTypeStoreSize(F->getType());
1901        int FieldAllocSize = RSExportType::GetTypeAllocSize(F->getType());
1902
1903        if (!VarName.empty())
1904          FieldName = VarName + "." + F->getName();
1905        else
1906          FieldName = F->getName();
1907
1908        // Alignment
1909        genAddPaddingToElementBuiler(C,
1910                                     (FieldOffset - Pos),
1911                                     ElementBuilderName,
1912                                     RenderScriptVar);
1913
1914        // eb.add(...)
1915        C.addFieldIndexMapping(F);
1916        if (F->getType()->getClass() != RSExportType::ExportClassRecord) {
1917          genAddElementToElementBuilder(C,
1918                                        F->getType(),
1919                                        FieldName,
1920                                        ElementBuilderName,
1921                                        RenderScriptVar,
1922                                        0);
1923        } else {
1924          std::string NewElementBuilderName(ElementBuilderName);
1925          NewElementBuilderName.append(1, '_');
1926
1927          genBuildElement(C,
1928                          NewElementBuilderName.c_str(),
1929                          static_cast<const RSExportRecordType*>(F->getType()),
1930                          RenderScriptVar,
1931                          /* IsInline = */true);
1932
1933          const std::string &VarName = FieldName;  // Hack for EB_ADD macro
1934          EB_ADD(NewElementBuilderName << ".create()");
1935        }
1936
1937        if (mRSContext->getTargetAPI() < SLANG_ICS_TARGET_API) {
1938          // There is padding within the field type. This is only necessary
1939          // for HC-targeted APIs.
1940          genAddPaddingToElementBuiler(C,
1941                                       (FieldAllocSize - FieldStoreSize),
1942                                       ElementBuilderName,
1943                                       RenderScriptVar);
1944        }
1945
1946        Pos = FieldOffset + FieldAllocSize;
1947      }
1948
1949      // There maybe some padding after the struct
1950      size_t RecordAllocSize = RSExportType::GetTypeAllocSize(ERT);
1951
1952      genAddPaddingToElementBuiler(C,
1953                                   RecordAllocSize - Pos,
1954                                   ElementBuilderName,
1955                                   RenderScriptVar);
1956    } else {
1957      slangAssert(false && "Unknown class of type");
1958    }
1959  }
1960}
1961
1962void RSReflection::genAddPaddingToElementBuiler(Context &C,
1963                                                int PaddingSize,
1964                                                const char *ElementBuilderName,
1965                                                const char *RenderScriptVar) {
1966  unsigned ArraySize = 0;   // Hack the EB_ADD macro
1967  while (PaddingSize > 0) {
1968    const std::string &VarName = C.createPaddingField();
1969    if (PaddingSize >= 4) {
1970      EB_ADD("Element.U32(" << RenderScriptVar << ")");
1971      PaddingSize -= 4;
1972    } else if (PaddingSize >= 2) {
1973      EB_ADD("Element.U16(" << RenderScriptVar << ")");
1974      PaddingSize -= 2;
1975    } else if (PaddingSize >= 1) {
1976      EB_ADD("Element.U8(" << RenderScriptVar << ")");
1977      PaddingSize -= 1;
1978    }
1979  }
1980  return;
1981}
1982
1983#undef EB_ADD
1984/******** Methods to create Element in Java of given record type /end ********/
1985
1986bool RSReflection::reflect(const std::string &OutputPathBase,
1987                           const std::string &OutputPackageName,
1988                           const std::string &RSPackageName,
1989                           const std::string &InputFileName,
1990                           const std::string &OutputBCFileName) {
1991  Context *C = NULL;
1992  std::string ResourceId = "";
1993  std::string PaddingPrefix = "";
1994
1995  if (mRSContext->getTargetAPI() < SLANG_ICS_TARGET_API) {
1996    PaddingPrefix = "#padding_";
1997  } else {
1998    PaddingPrefix = "#rs_padding_";
1999  }
2000
2001  if (!GetClassNameFromFileName(OutputBCFileName, ResourceId))
2002    return false;
2003
2004  if (ResourceId.empty())
2005    ResourceId = "<Resource ID>";
2006
2007  if (OutputPackageName.empty() || OutputPackageName == "-")
2008    C = new Context(OutputPathBase, InputFileName, "<Package Name>",
2009                    RSPackageName, ResourceId, PaddingPrefix, true);
2010  else
2011    C = new Context(OutputPathBase, InputFileName, OutputPackageName,
2012                    RSPackageName, ResourceId, PaddingPrefix, false);
2013
2014  if (C != NULL) {
2015    std::string ErrorMsg, ScriptClassName;
2016    // class ScriptC_<ScriptName>
2017    if (!GetClassNameFromFileName(InputFileName, ScriptClassName))
2018      return false;
2019
2020    if (ScriptClassName.empty())
2021      ScriptClassName = "<Input Script Name>";
2022
2023    ScriptClassName.insert(0, RS_SCRIPT_CLASS_NAME_PREFIX);
2024
2025    if (mRSContext->getLicenseNote() != NULL) {
2026      C->setLicenseNote(*(mRSContext->getLicenseNote()));
2027    }
2028
2029    if (!genScriptClass(*C, ScriptClassName, ErrorMsg)) {
2030      std::cerr << "Failed to generate class " << ScriptClassName << " ("
2031                << ErrorMsg << ")" << std::endl;
2032      return false;
2033    }
2034
2035    mGeneratedFileNames->push_back(ScriptClassName);
2036
2037    // class ScriptField_<TypeName>
2038    for (RSContext::const_export_type_iterator TI =
2039             mRSContext->export_types_begin(),
2040             TE = mRSContext->export_types_end();
2041         TI != TE;
2042         TI++) {
2043      const RSExportType *ET = TI->getValue();
2044
2045      if (ET->getClass() == RSExportType::ExportClassRecord) {
2046        const RSExportRecordType *ERT =
2047            static_cast<const RSExportRecordType*>(ET);
2048
2049        if (!ERT->isArtificial() && !genTypeClass(*C, ERT, ErrorMsg)) {
2050          std::cerr << "Failed to generate type class for struct '"
2051                    << ERT->getName() << "' (" << ErrorMsg << ")" << std::endl;
2052          return false;
2053        }
2054      }
2055    }
2056  }
2057
2058  return true;
2059}
2060
2061/************************** RSReflection::Context **************************/
2062const char *const RSReflection::Context::ApacheLicenseNote =
2063    "/*\n"
2064    " * Copyright (C) 2011-2012 The Android Open Source Project\n"
2065    " *\n"
2066    " * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
2067    " * you may not use this file except in compliance with the License.\n"
2068    " * You may obtain a copy of the License at\n"
2069    " *\n"
2070    " *      http://www.apache.org/licenses/LICENSE-2.0\n"
2071    " *\n"
2072    " * Unless required by applicable law or agreed to in writing, software\n"
2073    " * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
2074    " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or "
2075    "implied.\n"
2076    " * See the License for the specific language governing permissions and\n"
2077    " * limitations under the License.\n"
2078    " */\n"
2079    "\n";
2080
2081bool RSReflection::Context::openClassFile(const std::string &ClassName,
2082                                          std::string &ErrorMsg) {
2083  if (!mUseStdout) {
2084    mOF.clear();
2085    std::string Path =
2086        RSSlangReflectUtils::ComputePackagedPath(mOutputPathBase.c_str(),
2087                                                 mPackageName.c_str());
2088
2089    if (!SlangUtils::CreateDirectoryWithParents(Path, &ErrorMsg))
2090      return false;
2091
2092    std::string ClassFile = Path + OS_PATH_SEPARATOR_STR + ClassName + ".java";
2093
2094    mOF.open(ClassFile.c_str());
2095    if (!mOF.good()) {
2096      ErrorMsg = "failed to open file '" + ClassFile + "' for write";
2097      return false;
2098    }
2099  }
2100  return true;
2101}
2102
2103const char *RSReflection::Context::AccessModifierStr(AccessModifier AM) {
2104  switch (AM) {
2105    case AM_Public: return "public"; break;
2106    case AM_Protected: return "protected"; break;
2107    case AM_Private: return "private"; break;
2108    case AM_PublicSynchronized: return "public synchronized"; break;
2109    default: return ""; break;
2110  }
2111}
2112
2113bool RSReflection::Context::startClass(AccessModifier AM,
2114                                       bool IsStatic,
2115                                       const std::string &ClassName,
2116                                       const char *SuperClassName,
2117                                       std::string &ErrorMsg) {
2118  if (mVerbose)
2119    std::cout << "Generating " << ClassName << ".java ..." << std::endl;
2120
2121  // Open file for class
2122  if (!openClassFile(ClassName, ErrorMsg))
2123    return false;
2124
2125  // License
2126  out() << mLicenseNote;
2127
2128  // Notice of generated file
2129  out() << "/*" << std::endl;
2130  out() << " * This file is auto-generated. DO NOT MODIFY!" << std::endl;
2131  out() << " * The source Renderscript file: " << mInputRSFile << std::endl;
2132  out() << " */" << std::endl;
2133
2134  // Package
2135  if (!mPackageName.empty())
2136    out() << "package " << mPackageName << ";" << std::endl;
2137  out() << std::endl;
2138
2139  // Imports
2140  out() << "import " << mRSPackageName << ".*;" << std::endl;
2141  out() << "import android.content.res.Resources;" << std::endl;
2142  out() << std::endl;
2143
2144  // All reflected classes should be annotated as hidden, so that they won't
2145  // be exposed in SDK.
2146  out() << "/**" << std::endl;
2147  out() << " * @hide" << std::endl;
2148  out() << " */" << std::endl;
2149
2150  out() << AccessModifierStr(AM) << ((IsStatic) ? " static" : "") << " class "
2151        << ClassName;
2152  if (SuperClassName != NULL)
2153    out() << " extends " << SuperClassName;
2154
2155  startBlock();
2156
2157  mClassName = ClassName;
2158
2159  return true;
2160}
2161
2162void RSReflection::Context::endClass() {
2163  endBlock();
2164  if (!mUseStdout)
2165    mOF.close();
2166  clear();
2167  return;
2168}
2169
2170void RSReflection::Context::startBlock(bool ShouldIndent) {
2171  if (ShouldIndent)
2172    indent() << "{" << std::endl;
2173  else
2174    out() << " {" << std::endl;
2175  incIndentLevel();
2176  return;
2177}
2178
2179void RSReflection::Context::endBlock() {
2180  decIndentLevel();
2181  indent() << "}" << std::endl << std::endl;
2182  return;
2183}
2184
2185void RSReflection::Context::startTypeClass(const std::string &ClassName) {
2186  indent() << "public static class " << ClassName;
2187  startBlock();
2188  return;
2189}
2190
2191void RSReflection::Context::endTypeClass() {
2192  endBlock();
2193  return;
2194}
2195
2196void RSReflection::Context::startFunction(AccessModifier AM,
2197                                          bool IsStatic,
2198                                          const char *ReturnType,
2199                                          const std::string &FunctionName,
2200                                          int Argc, ...) {
2201  ArgTy Args;
2202  va_list vl;
2203  va_start(vl, Argc);
2204
2205  for (int i = 0; i < Argc; i++) {
2206    const char *ArgType = va_arg(vl, const char*);
2207    const char *ArgName = va_arg(vl, const char*);
2208
2209    Args.push_back(std::make_pair(ArgType, ArgName));
2210  }
2211  va_end(vl);
2212
2213  startFunction(AM, IsStatic, ReturnType, FunctionName, Args);
2214
2215  return;
2216}
2217
2218void RSReflection::Context::startFunction(AccessModifier AM,
2219                                          bool IsStatic,
2220                                          const char *ReturnType,
2221                                          const std::string &FunctionName,
2222                                          const ArgTy &Args) {
2223  indent() << AccessModifierStr(AM) << ((IsStatic) ? " static " : " ")
2224           << ((ReturnType) ? ReturnType : "") << " " << FunctionName << "(";
2225
2226  bool FirstArg = true;
2227  for (ArgTy::const_iterator I = Args.begin(), E = Args.end();
2228       I != E;
2229       I++) {
2230    if (!FirstArg)
2231      out() << ", ";
2232    else
2233      FirstArg = false;
2234
2235    out() << I->first << " " << I->second;
2236  }
2237
2238  out() << ")";
2239  startBlock();
2240
2241  return;
2242}
2243
2244void RSReflection::Context::endFunction() {
2245  endBlock();
2246  return;
2247}
2248
2249bool RSReflection::Context::addTypeNameForElement(
2250    const std::string &TypeName) {
2251  if (mTypesToCheck.find(TypeName) == mTypesToCheck.end()) {
2252    mTypesToCheck.insert(TypeName);
2253    return true;
2254  } else {
2255    return false;
2256  }
2257}
2258
2259bool RSReflection::Context::addTypeNameForFieldPacker(
2260    const std::string &TypeName) {
2261  if (mFieldPackerTypes.find(TypeName) == mFieldPackerTypes.end()) {
2262    mFieldPackerTypes.insert(TypeName);
2263    return true;
2264  } else {
2265    return false;
2266  }
2267}
2268
2269}  // namespace slang
2270