//===- StmtIterator.cpp - Iterators for Statements ------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file defines internal methods for StmtIterator.

//

//===----------------------------------------------------------------------===//

#include "clang/AST/StmtIterator.h"

#include "clang/AST/Decl.h"

#include "clang/AST/Type.h"

#include "clang/Basic/LLVM.h"

#include "llvm/Support/Casting.h"

#include <cassert>

#include <cstdint>

using namespace clang;

// FIXME: Add support for dependent-sized array types in C++?

// Does it even make sense to build a CFG for an uninstantiated template?

static inline const VariableArrayType *FindVA(const Type* t) {

  while (const ArrayType *vt = dyn_cast<ArrayType>(t)) {

    if (const VariableArrayType *vat = dyn_cast<VariableArrayType>(vt))

      if (vat->getSizeExpr())

        return vat;

    t = vt->getElementType().getTypePtr();

  }

  return nullptr;

}

void StmtIteratorBase::NextVA() {

  assert(getVAPtr());

  const VariableArrayType *p = getVAPtr();

  p = FindVA(p->getElementType().getTypePtr());

  setVAPtr(p);

  if (p)

    return;

  if (inDeclGroup()) {

    if (VarDecl* VD = dyn_cast<VarDecl>(*DGI))

      if (VD->hasInit())

        return;

    NextDecl();

  }

  else {

    assert(inSizeOfTypeVA());

    RawVAPtr = 0;

  }

}

void StmtIteratorBase::NextDecl(bool ImmediateAdvance) {

  assert(getVAPtr() == nullptr);

  assert(inDeclGroup());

  if (ImmediateAdvance)

    ++DGI;

  for ( ; DGI != DGE; ++DGI)

    if (HandleDecl(*DGI))

      return;

  RawVAPtr = 0;

}

bool StmtIteratorBase::HandleDecl(Decl* D) {

  if (VarDecl* VD = dyn_cast<VarDecl>(D)) {

    if (const VariableArrayType* VAPtr = FindVA(VD->getType().getTypePtr())) {

      setVAPtr(VAPtr);

      return true;

    }

    if (VD->getInit())

      return true;

  }

  else if (TypedefNameDecl* TD = dyn_cast<TypedefNameDecl>(D)) {

    if (const VariableArrayType* VAPtr =

        FindVA(TD->getUnderlyingType().getTypePtr())) {

      setVAPtr(VAPtr);

      return true;

    }

  }

  else if (EnumConstantDecl* ECD = dyn_cast<EnumConstantDecl>(D)) {

    if (ECD->getInitExpr())

      return true;

  }

  return false;

}

StmtIteratorBase::StmtIteratorBase(Decl** dgi, Decl** dge)

    : DGI(dgi), RawVAPtr(DeclGroupMode), DGE(dge) {

  NextDecl(false);

}

StmtIteratorBase::StmtIteratorBase(const VariableArrayType* t)

    : DGI(nullptr), RawVAPtr(SizeOfTypeVAMode) {

  RawVAPtr |= reinterpret_cast<uintptr_t>(t);

}

Stmt*& StmtIteratorBase::GetDeclExpr() const {

  if (const VariableArrayType* VAPtr = getVAPtr()) {

    assert(VAPtr->SizeExpr);

    return const_cast<Stmt*&>(VAPtr->SizeExpr);

  }

  assert(inDeclGroup());

  VarDecl* VD = cast<VarDecl>(*DGI);

  return *VD->getInitAddress();

}