//===--- Designator.h - Initialization Designator ---------------*- C++ -*-===//

//

// 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 interfaces used to represent designators (a la

// C99 designated initializers) during parsing.

//

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

#ifndef LLVM_CLANG_SEMA_DESIGNATOR_H

#define LLVM_CLANG_SEMA_DESIGNATOR_H

#include "clang/Basic/SourceLocation.h"

#include "llvm/ADT/SmallVector.h"

namespace clang {

class Expr;

class IdentifierInfo;

/// Designator - A designator in a C99 designated initializer.

///

/// This class is a discriminated union which holds the various

/// different sorts of designators possible. A Designation is an array of

/// these.  An example of a designator are things like this:

///

///      [8] .field [47]        // C99 designation: 3 designators

///      [8 ... 47]  field:     // GNU extensions: 2 designators

///

/// These occur in initializers, e.g.:

///

///      int a[10] = {2, 4, [8]=9, 10};

///

class Designator {

  /// A field designator, e.g., ".x = 42".

  struct FieldDesignatorInfo {

    /// Refers to the field being initialized.

    const IdentifierInfo *FieldName;

    /// The location of the '.' in the designated initializer.

    SourceLocation DotLoc;

    /// The location of the field name in the designated initializer.

    SourceLocation FieldLoc;

    FieldDesignatorInfo(const IdentifierInfo *FieldName, SourceLocation DotLoc,

                        SourceLocation FieldLoc)

        : FieldName(FieldName), DotLoc(DotLoc), FieldLoc(FieldLoc) {}

  };

  /// An array designator, e.g., "[42] = 0".

  struct ArrayDesignatorInfo {

    Expr *Index;

    // The location of the '[' in the designated initializer.

    SourceLocation LBracketLoc;

    // The location of the ']' in the designated initializer.

    mutable SourceLocation RBracketLoc;

    ArrayDesignatorInfo(Expr *Index, SourceLocation LBracketLoc)

        : Index(Index), LBracketLoc(LBracketLoc) {}

  };

  /// An array range designator, e.g. "[42 ... 50] = 1".

  struct ArrayRangeDesignatorInfo {

    Expr *Start;

    Expr *End;

    // The location of the '[' in the designated initializer.

    SourceLocation LBracketLoc;

    // The location of the '...' in the designated initializer.

    SourceLocation EllipsisLoc;

    // The location of the ']' in the designated initializer.

    mutable SourceLocation RBracketLoc;

    ArrayRangeDesignatorInfo(Expr *Start, Expr *End, SourceLocation LBracketLoc,

                             SourceLocation EllipsisLoc)

        : Start(Start), End(End), LBracketLoc(LBracketLoc),

          EllipsisLoc(EllipsisLoc) {}

  };

  /// The kind of designator this describes.

  enum DesignatorKind {

    FieldDesignator,

    ArrayDesignator,

    ArrayRangeDesignator

  };

  DesignatorKind Kind;

  union {

    FieldDesignatorInfo FieldInfo;

    ArrayDesignatorInfo ArrayInfo;

    ArrayRangeDesignatorInfo ArrayRangeInfo;

  };

  Designator(DesignatorKind Kind) : Kind(Kind) {}

public:

  bool isFieldDesignator() const { return Kind == FieldDesignator; }

  bool isArrayDesignator() const { return Kind == ArrayDesignator; }

  bool isArrayRangeDesignator() const { return Kind == ArrayRangeDesignator; }

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

  // FieldDesignatorInfo

  /// Creates a field designator.

  static Designator CreateFieldDesignator(const IdentifierInfo *FieldName,

                                          SourceLocation DotLoc,

                                          SourceLocation FieldLoc) {

    Designator D(FieldDesignator);

    new (&D.FieldInfo) FieldDesignatorInfo(FieldName, DotLoc, FieldLoc);

    return D;

  }

  const IdentifierInfo *getFieldDecl() const {

    assert(isFieldDesignator() && "Invalid accessor");

    return FieldInfo.FieldName;

  }

  SourceLocation getDotLoc() const {

    assert(isFieldDesignator() && "Invalid accessor");

    return FieldInfo.DotLoc;

  }

  SourceLocation getFieldLoc() const {

    assert(isFieldDesignator() && "Invalid accessor");

    return FieldInfo.FieldLoc;

  }

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

  // ArrayDesignatorInfo:

  /// Creates an array designator.

  static Designator CreateArrayDesignator(Expr *Index,

                                          SourceLocation LBracketLoc) {

    Designator D(ArrayDesignator);

    new (&D.ArrayInfo) ArrayDesignatorInfo(Index, LBracketLoc);

    return D;

  }

  Expr *getArrayIndex() const {

    assert(isArrayDesignator() && "Invalid accessor");

    return ArrayInfo.Index;

  }

  SourceLocation getLBracketLoc() const {

    assert((isArrayDesignator() || isArrayRangeDesignator()) &&

           "Invalid accessor");

    return isArrayDesignator() ? 
ArrayInfo.LBracketLoc408

                               : 
ArrayRangeInfo.LBracketLoc27
;

  }

  SourceLocation getRBracketLoc() const {

    assert((isArrayDesignator() || isArrayRangeDesignator()) &&

           "Invalid accessor");

    return isArrayDesignator() ? 
ArrayInfo.RBracketLoc408

                               : 
ArrayRangeInfo.RBracketLoc27
;

  }

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

  // ArrayRangeDesignatorInfo:

  /// Creates a GNU array-range designator.

  static Designator CreateArrayRangeDesignator(Expr *Start, Expr *End,

                                               SourceLocation LBracketLoc,

                                               SourceLocation EllipsisLoc) {

    Designator D(ArrayRangeDesignator);

    new (&D.ArrayRangeInfo)

        ArrayRangeDesignatorInfo(Start, End, LBracketLoc, EllipsisLoc);

    return D;

  }

  Expr *getArrayRangeStart() const {

    assert(isArrayRangeDesignator() && "Invalid accessor");

    return ArrayRangeInfo.Start;

  }

  Expr *getArrayRangeEnd() const {

    assert(isArrayRangeDesignator() && "Invalid accessor");

    return ArrayRangeInfo.End;

  }

  SourceLocation getEllipsisLoc() const {

    assert(isArrayRangeDesignator() && "Invalid accessor");

    return ArrayRangeInfo.EllipsisLoc;

  }

  void setRBracketLoc(SourceLocation RBracketLoc) const {

    assert((isArrayDesignator() || isArrayRangeDesignator()) &&

           "Invalid accessor");

    if (isArrayDesignator())

      ArrayInfo.RBracketLoc = RBracketLoc;

    else

      ArrayRangeInfo.RBracketLoc = RBracketLoc;

  }

};

/// Designation - Represent a full designation, which is a sequence of

/// designators.  This class is mostly a helper for InitListDesignations.

class Designation {

  /// Designators - The actual designators for this initializer.

  SmallVector<Designator, 2> Designators;

public:

  /// AddDesignator - Add a designator to the end of this list.

  void AddDesignator(Designator D) { Designators.push_back(D); }

  bool empty() const { return Designators.empty(); }

  unsigned getNumDesignators() const { return Designators.size(); }

  const Designator &getDesignator(unsigned Idx) const {

    assert(Idx < Designators.size());

    return Designators[Idx];

  }

};

} // end namespace clang

#endif