slang_rs_export_var.cpp revision 796e7b1400d3f3f7c07496d88bb48129ea925bb9 
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_export_var.h"
18
19#include "clang/AST/ASTContext.h"
20#include "clang/AST/Type.h"
21
22#include "llvm/ADT/APSInt.h"
23
24#include "slang_rs_context.h"
25#include "slang_rs_export_type.h"
26
27namespace slang {
28
29RSExportVar::RSExportVar(RSContext *Context,
30                         const clang::VarDecl *VD,
31                         const RSExportType *ET)
32    : RSExportable(Context, RSExportable::EX_VAR),
33      mName(VD->getName().data(), VD->getName().size()),
34      mET(ET),
35      mIsConst(false),
36      mIsUnsigned(false),
37      mArraySize(0),
38      mNumInits(0) {
39  // mInit - Evaluate initializer expression
40  const clang::Expr *Initializer = VD->getAnyInitializer();
41  if (Initializer != NULL) {
42    switch (ET->getClass()) {
43      case RSExportType::ExportClassPrimitive:
44      case RSExportType::ExportClassVector: {
45        Initializer->EvaluateAsRValue(mInit, Context->getASTContext());
46        break;
47      }
48      case RSExportType::ExportClassPointer: {
49        if (Initializer->isNullPointerConstant(Context->getASTContext(),
50                clang::Expr::NPC_ValueDependentIsNotNull)) {
51          mInit.Val = clang::APValue(llvm::APSInt(1));
52        } else {
53          if (!Initializer->EvaluateAsRValue(mInit, Context->getASTContext())) {
54            Context->ReportError(Initializer->getExprLoc(),
55                                 "initializer is not an R-value");
56          }
57        }
58        break;
59      }
60      case RSExportType::ExportClassConstantArray: {
61        const clang::InitListExpr *IList =
62            static_cast<const clang::InitListExpr*>(Initializer);
63        if (!IList) {
64          Context->ReportError(VD->getLocation(),
65                               "Unable to find initializer list");
66          break;
67        }
68        const RSExportConstantArrayType *ECAT =
69            static_cast<const RSExportConstantArrayType*>(ET);
70        mArraySize = ECAT->getSize();
71        mNumInits = IList->getNumInits();
72        for (unsigned int i = 0; i < mNumInits; i++) {
73          clang::Expr::EvalResult tempInit;
74          if (!IList->getInit(i)->EvaluateAsRValue(tempInit,
75                                                   Context->getASTContext())) {
76            Context->ReportError(IList->getInit(i)->getExprLoc(),
77                                 "initializer is not an R-value");
78          }
79          mInitArray.push_back(tempInit);
80        }
81        break;
82      }
83      case RSExportType::ExportClassMatrix:
84      case RSExportType::ExportClassRecord: {
85        Context->ReportError(
86            VD->getLocation(),
87            "Reflection of initializer to variable '%0' (of type "
88            "'%1') is unsupported currently.")
89            << mName << ET->getName();
90        break;
91      }
92      default: {
93        slangAssert(false && "Unknown class of type");
94      }
95    }
96  }
97
98  clang::QualType QT = VD->getTypeSourceInfo()->getType();
99  if (!QT.isNull()) {
100    mIsConst = QT.isConstQualified();
101    mIsUnsigned = QT->hasUnsignedIntegerRepresentation();
102    if (QT == Context->getASTContext().BoolTy) {
103      mIsUnsigned = false;
104    }
105  }
106}
107
108}  // namespace slang
109