include/comma/ast/RangeAttrib.h

Go to the documentation of this file.

//===-- ast/RangeAttrib.h ------------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license. See LICENSE.txt for details.
//
// Copyright (C) 2009, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_AST_RANGEATTRIB_HDR_GUARD
#define COMMA_AST_RANGEATTRIB_HDR_GUARD

#include "comma/ast/AstBase.h"
#include "comma/ast/Expr.h"

namespace comma {

//===----------------------------------------------------------------------===//
// RangeAttrib
//
class RangeAttrib : public Ast {

public:



    const Ast *getPrefix() const { return prefix; }
    Ast *getPrefix() { return prefix; }

    Location getLocation() const { return loc; }


    virtual const DiscreteType *getType() const = 0;
    virtual DiscreteType *getType() = 0;

    // Support isa/dyn_cast.
    static bool classof(const RangeAttrib *node) { return true; }
    static bool classof(const Ast *node) {
        return denotesRangeAttrib(node->getKind());
    }

protected:
    RangeAttrib(AstKind kind, Ast *prefix, Location loc)
        : Ast(kind), prefix(prefix), loc(loc) { }

    static bool denotesRangeAttrib(AstKind kind) {
        return (kind == AST_ScalarRangeAttrib || kind == AST_ArrayRangeAttrib);
    }

private:
    Ast *prefix;
    Location loc;
};

//===----------------------------------------------------------------------===//
// ArrayRangeAttrib
//
class ArrayRangeAttrib : public RangeAttrib
{
public:
    ArrayRangeAttrib(Expr *prefix, Expr *dimension, Location loc)
        : RangeAttrib(AST_ArrayRangeAttrib, prefix, loc),
          dimExpr(dimension) {
        assert(llvm::isa<ArrayType>(prefix->getType()) &&
               "Invalid prefix for array range attribute!");
        assert(dimension->isStaticDiscreteExpr() &&
               "Non-static dimension given to range attribute!");
        llvm::APInt value;
        dimension->staticDiscreteValue(value);
        dimValue = value.getZExtValue();
    }

    ArrayRangeAttrib(Expr *prefix, Location loc)
        : RangeAttrib(AST_ArrayRangeAttrib, prefix, loc),
          dimExpr(0), dimValue(0) {
        assert(llvm::isa<ArrayType>(prefix->getType()) &&
               "Invalid prefix for array range attribute!");
    }


    const Expr *getPrefix() const {
        return llvm::cast<Expr>(RangeAttrib::getPrefix());
    }
    Expr *getPrefix() {
        return llvm::cast<Expr>(RangeAttrib::getPrefix());
    }

    bool hasImplicitDimension() const { return dimExpr == 0; }





    Expr *getDimensionExpr() { return dimExpr; }
    const Expr *getDimensionExpr() const { return dimExpr; }

    unsigned getDimension() const { return dimValue; }


    const DiscreteType *getType() const {
        const ArrayType *arrTy = llvm::cast<ArrayType>(getPrefix()->getType());
        return arrTy->getIndexType(dimValue);
    };

    DiscreteType *getType() {
        ArrayType *arrTy = llvm::cast<ArrayType>(getPrefix()->getType());
        return arrTy->getIndexType(dimValue);
    }

    // Support isa/dyn_cast.
    static bool classof(const ArrayRangeAttrib *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ArrayRangeAttrib;
    }

private:
    Expr *dimExpr;

    unsigned dimValue;
};

//===----------------------------------------------------------------------===//
// ScalarRangeAttrib
//
class ScalarRangeAttrib : public RangeAttrib
{
public:
    ScalarRangeAttrib(DiscreteType *prefix, Location loc)
        : RangeAttrib(AST_ScalarRangeAttrib, prefix, loc) { }


    const DiscreteType *getPrefix() const {
        return llvm::cast<DiscreteType>(RangeAttrib::getPrefix());
    }
    DiscreteType *getPrefix() {
        return llvm::cast<DiscreteType>(RangeAttrib::getPrefix());
    }


    const DiscreteType *getType() const { return getPrefix(); }
    DiscreteType *getType() { return getPrefix(); }

    // Support isa/dyn_cast.
    static bool classof(const ScalarRangeAttrib *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ScalarRangeAttrib;
    }
};

} // end comma namespace.

#endif

---