Welcome to the NetCologne GmbH open source mirroring service!

This machine mirrors various open-source projects. 20 Gbit/s uplink.

If there are any issues or you want another project mirrored, please contact mirror-service -=AT=- netcologne DOT de !

include/comma/ast/AttribExpr.h

Go to the documentation of this file.

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

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

#ifndef COMMA_AST_ATTRIBEXPR_HDR_GUARD
#define COMMA_AST_ATTRIBEXPR_HDR_GUARD

#include "comma/ast/Expr.h"
#include "comma/basic/Attributes.h"

namespace comma {

//===----------------------------------------------------------------------===//
// AttribExpr
//
class AttribExpr : public Expr {

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

    attrib::AttributeID getAttributeID() const {
        // AttributeID's are stored in the lower Ast bits field.
        return static_cast<attrib::AttributeID>(bits);
    }

    // Support isa and dyn_cast.
    static bool classof(const AttribExpr *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesAttribExpr();
    }

protected:
    AttribExpr(AstKind kind, Ast *prefix, PrimaryType *type, Location loc)
        : Expr(kind, type, loc),
          prefix(prefix) {
        bits = correspondingID(kind);
        assert(this->denotesAttribExpr());
        assert(getAttributeID() != attrib::UNKNOWN_ATTRIBUTE);
    }

    AttribExpr(AstKind kind, Ast *prefix, Location loc)
        : Expr(kind, loc),
          prefix(prefix) {
        bits = correspondingID(kind);
        assert(this->denotesAttribExpr());
        assert(getAttributeID() != attrib::UNKNOWN_ATTRIBUTE);
    }

    static attrib::AttributeID correspondingID(AstKind kind);

    Ast *prefix;
};

//===----------------------------------------------------------------------===//
// ScalarBoundAE
//
class ScalarBoundAE : public AttribExpr {

public:
    virtual ~ScalarBoundAE() { }

    bool isFirst() const { return llvm::isa<FirstAE>(this); }

    bool isLast() const { return llvm::isa<LastAE>(this); }


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


    const DiscreteType *getType() const {
        return llvm::cast<DiscreteType>(Expr::getType());
    }
    DiscreteType *getType() {
        return llvm::cast<DiscreteType>(Expr::getType());
    }

    // Support isa/dyn_cast.
    static bool classof(const ScalarBoundAE *node) { return true; }
    static bool classof(const Ast *node) {
        AstKind kind = node->getKind();
        return (kind == AST_FirstAE || kind == AST_LastAE);
    }

protected:
    ScalarBoundAE(AstKind kind, DiscreteType *prefix, Location loc)
        : AttribExpr(kind, prefix, prefix, loc) {
        assert(kind == AST_FirstAE || kind == AST_LastAE);
    }
};

//===----------------------------------------------------------------------===//
// FirstAE
//
class FirstAE : public ScalarBoundAE {

public:
    FirstAE(DiscreteType *prefix, Location loc)
        : ScalarBoundAE(AST_FirstAE, prefix, loc) { }

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

//===----------------------------------------------------------------------===//
// LastAE
//
class LastAE : public ScalarBoundAE {

public:
    LastAE(DiscreteType *prefix, Location loc)
        : ScalarBoundAE(AST_LastAE, prefix, loc) { }

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

//===----------------------------------------------------------------------===//
// ArrayBoundAE
//
class ArrayBoundAE : public AttribExpr {

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



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

    unsigned getDimension() const { return dimValue; }

    bool isFirst() const;

    bool isLast() const;


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


    const ArrayType *getPrefixType() const {
        return llvm::cast<ArrayType>(getPrefix()->getType());
    }
    ArrayType *getPrefixType() {
        return llvm::cast<ArrayType>(getPrefix()->getType());
    }


    const IntegerType *getType() const {
        return llvm::cast<IntegerType>(Expr::getType());
    }
    IntegerType *getType() {
        return llvm::cast<IntegerType>(Expr::getType());
    }

    // Support isa/dyn_cast.
    static bool classof(const ArrayBoundAE *node) { return true; }
    static bool classof(const Ast *node) {
        AstKind kind = node->getKind();
        return (kind == AST_FirstArrayAE || kind == AST_LastArrayAE);
    }

protected:
    ArrayBoundAE(AstKind kind, Expr *prefix, Expr *dimension, Location loc);

    ArrayBoundAE(AstKind kind, Expr *prefix, Location loc);

    Expr *dimExpr;

    unsigned dimValue;
};

//===----------------------------------------------------------------------===//
// FirstArrayAE
//
class FirstArrayAE : public ArrayBoundAE {

public:
    FirstArrayAE(Expr *prefix, Expr *dimension, Location loc)
        : ArrayBoundAE(AST_FirstArrayAE, prefix, dimension, loc) { }

    FirstArrayAE(Expr *prefix, Location loc)
        : ArrayBoundAE(AST_FirstArrayAE, prefix, loc) { }

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

//===----------------------------------------------------------------------===//
// LastArrayAE
//
class LastArrayAE : public ArrayBoundAE {

public:
    LastArrayAE(Expr *prefix, Expr *dimension, Location loc)
        : ArrayBoundAE(AST_LastArrayAE, prefix, dimension, loc) { }

    LastArrayAE(Expr *prefix, Location loc)
        : ArrayBoundAE(AST_LastArrayAE, prefix, loc) { }

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

//===----------------------------------------------------------------------===//
// Inline methods now that the hierarchy is in place.

inline bool ArrayBoundAE::isFirst() const {
    return llvm::isa<FirstArrayAE>(this);
}

inline bool ArrayBoundAE::isLast() const {
    return llvm::isa<LastArrayAE>(this);
}

} // end comma namespace.

#endif

---