include/comma/ast/AggExpr.h

Go to the documentation of this file.

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

#ifndef COMMA_AST_AGGEXPR_HDR_GUARD
#define COMMA_AST_AGGEXPR_HDR_GUARD

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

#include "comma/ast/Expr.h"
#include "comma/ast/Type.h"
#include "comma/ast/TypeRef.h"

namespace comma {

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

public:
    Identifier(IdentifierInfo *name, Location loc)
        : Ast(AST_Identifier), name(name), loc(loc) { }

    IdentifierInfo *getIdInfo() const { return name; }

    Location getLocation() const { return loc; }

    void setIdInfo(IdentifierInfo *name) { this->name = name; }

    void setLocation(Location loc) { this->loc = loc; }

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

private:
    IdentifierInfo *name;
    Location loc;
};

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

public:

    ComponentKey(Expr *node)
        : Ast(AST_ComponentKey), rep(node), loc(node->getLocation()) { }
    ComponentKey(Identifier *node)
        : Ast(AST_ComponentKey), rep(node), loc(node->getLocation()) { }
    ComponentKey(Range *node)
        : Ast(AST_ComponentKey), rep(node), loc(node->getLowerLocation()) { }
    ComponentKey(TypeRef *node)
        : Ast(AST_ComponentKey), rep(node), loc(node->getLocation()) { }
    ComponentKey(ComponentDecl *node, Location loc)
        : Ast(AST_ComponentKey), rep(node), loc(loc) { }


    bool denotesExpr()       const { return llvm::isa<Expr>(rep);           }
    bool denotesIdentifier() const { return llvm::isa<Identifier>(rep);     }
    bool denotesRange()      const { return llvm::isa<Range>(rep);          }
    bool denotesType()       const { return llvm::isa<TypeRef>(rep);        }
    bool denotesComponent()  const { return llvm::isa<ComponentDecl>(rep) ; }

    Location getLocation() const { return loc; }

    void setLocation(Location loc) { this->loc = loc; }




    Expr *getAsExpr() {
        return llvm::dyn_cast<Expr>(rep);
    }
    Identifier *getAsIdentifier() {
        return llvm::dyn_cast<Identifier>(rep);
    }
    Range *getAsRange() {
        return llvm::dyn_cast<Range>(rep);
    }
    TypeRef *getAsTypeRef() {
        return llvm::dyn_cast<TypeRef>(rep);
    }
    DiscreteType *getAsDiscreteType() {
        if (TypeRef *ref = getAsTypeRef()) {
            return llvm::cast<DiscreteType>(ref->getTypeDecl()->getType());
        }
        return 0;
    }
    ComponentDecl *getAsComponent() {
        return llvm::dyn_cast<ComponentDecl>(rep);
    }

    const Expr *getAsExpr() const {
        return llvm::dyn_cast<Expr>(rep);
    }
    const Identifier *getAsIdentifier() const {
        return llvm::dyn_cast<Identifier>(rep);
    }
    const Range *getAsRange() const {
        return llvm::dyn_cast<Range>(rep);
    }
    const TypeRef *getAsTypeRef() const {
        return llvm::dyn_cast<TypeRef>(rep);
    }
    const DiscreteType *getAsDiscreteType() const {
        if (const TypeRef *ref = getAsTypeRef()) {
            return llvm::cast<DiscreteType>(ref->getTypeDecl()->getType());
        }
        return 0;
    }
    const ComponentDecl *getAsComponent() const {
        return llvm::dyn_cast<ComponentDecl>(rep);
    }

    Ast *&getRep() { return rep; }
    const Ast *getRep() const { return rep; }


    void setKey(Expr          *node) { rep = node; }
    void setKey(Range         *node) { rep = node; }
    void setKey(TypeRef       *node) { rep = node; }
    void setKey(Identifier    *node) { rep = node; }
    void setKey(ComponentDecl *node) { rep = node; }

    bool isStatic() const;


    Expr *getLowerExpr();
    Expr *getUpperExpr();

    void getLowerValue(llvm::APInt &value) const;
    void getUpperValue(llvm::APInt &value) const;



    bool isComparable() const { return !denotesIdentifier() && isStatic(); }

    static bool compareKeysU(const ComponentKey *X, const ComponentKey *Y);

    static bool compareKeysS(const ComponentKey *X, const ComponentKey *Y);

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

private:
    Ast *rep;
    Location loc;
};

//===----------------------------------------------------------------------===//
// ComponentKeyList
//
class ComponentKeyList {

public:
    static ComponentKeyList *create(ComponentKey **keys, unsigned numKeys,
                                    Expr *expr);

    static void dispose(ComponentKeyList *CL);


    const Expr *getExpr() const { return expr; }
    Expr *getExpr() { return expr; }

    void setExpr(Expr *expr) { this->expr = expr; }

    unsigned numKeys() const { return keyCount; }

    Location getLocation() const { return keys[0]->getLocation(); }



    const ComponentKey *getKey(unsigned i) const {
        assert(i < keyCount && "Index out of range!");
        return keys[i];
    }
    ComponentKey *&getKey(unsigned i) {
        assert(i < keyCount && "Index out of range!");
        return keys[i];
    }

    template <class T>
    T *resolveKey(unsigned i) {
        assert(i < keyCount && "Index out of range!");
        return llvm::dyn_cast<T>(keys[i]->getRep());
    }

    template <class T>
    const T *resolveKey(unsigned i) const {
        assert(i < keyCount && "Index out of range!");
        return llvm::dyn_cast<T>(keys[i]->getRep());
    }

    Ast *&getRawKey(unsigned i) {
        assert(i < keyCount && "Index out of range!");
        return keys[i]->getRep();
    }
    const Ast *getRawKey(unsigned i) const {
        assert(i < keyCount && "Index out of range!");
        return keys[i]->getRep();
    }


    void setKey(unsigned i, Expr *node) {
        assert(i < keyCount && "Index out of range!");
        keys[i]->setKey(node);
    }
    void setKey(unsigned i, Identifier *node) {
        assert(i < keyCount && "Index out of range!");
        keys[i]->setKey(node);
    }
    void setKey(unsigned i, Range *node) {
        assert(i < keyCount && "Index out of range!");
        keys[i]->setKey(node);
    }
    void setKey(unsigned i, TypeRef *node) {
        assert(i < keyCount && "Index out of range!");
        keys[i]->setKey(node);
    }




    typedef ComponentKey **iterator;
    iterator begin() { return keys; }
    iterator end() { return &keys[keyCount]; }

    typedef ComponentKey *const *const_iterator;
    const_iterator begin() const { return keys; }
    const_iterator end() const { return &keys[keyCount]; }

private:
    ComponentKeyList(ComponentKey **keys, unsigned numKeys, Expr *expr);

    ComponentKeyList(const ComponentKeyList &CL); // do not implement.
    ComponentKeyList &operator =(const ComponentKeyList &CL); // Likewise.

    ComponentKey **keys;
    unsigned keyCount;
    Expr *expr;
};

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

public:
    ~AggregateExpr();

    AggregateExpr(Location loc) : Expr(AST_AggregateExpr, loc), others(0) { }

    bool empty() const;

    bool hasStaticIndices() const;

    unsigned numComponents() const;

    bool isPurelyPositional() const { return !hasKeyedComponents(); }

    bool isPurelyKeyed() const { return !hasPositionalComponents(); }



    bool hasPositionalComponents() const {
        return !positionalComponents.empty();
    }

    unsigned numPositionalComponents() const {
        return positionalComponents.size();
    }

    void addComponent(Expr *expr) {
        positionalComponents.push_back(expr);
    }


    typedef std::vector<Expr*>::iterator pos_iterator;
    pos_iterator pos_begin() { return positionalComponents.begin(); }
    pos_iterator pos_end() { return positionalComponents.end(); }

    typedef std::vector<Expr*>::const_iterator const_pos_iterator;
    const_pos_iterator pos_begin() const {
        return positionalComponents.begin();
    }
    const_pos_iterator pos_end() const {
        return positionalComponents.end();
    }




    void addComponent(ComponentKeyList *keyList) {
        this->keyedComponents.push_back(keyList);
    }

    bool hasKeyedComponents() const { return !keyedComponents.empty(); }

    unsigned numKeyLists() const { return keyedComponents.size(); }

    unsigned numKeys() const;


    typedef std::vector<ComponentKeyList*>::iterator kl_iterator;
    kl_iterator kl_begin() { return keyedComponents.begin(); }
    kl_iterator kl_end() { return keyedComponents.end(); }

    typedef std::vector<ComponentKeyList*>::const_iterator const_kl_iterator;
    const_kl_iterator kl_begin() const { return keyedComponents.begin(); }
    const_kl_iterator kl_end() const { return keyedComponents.end(); }

private:
    class KeyIterator {
        typedef std::vector<ComponentKeyList*> CKLVector;

        CKLVector &keys;
        unsigned keyIdx;        // Index into the \c keys vector.
        unsigned listIdx;       // Index into the corresponding KeyList.

        KeyIterator(CKLVector &keys,
                    unsigned keyIdx, unsigned listIdx)
            : keys(keys), keyIdx(keyIdx), listIdx(listIdx) { }

        KeyIterator(CKLVector &keys)
            : keys(keys), keyIdx(0), listIdx(0) { }

        static KeyIterator getSentinel(CKLVector &keys) {
            return KeyIterator(keys, keys.size(), 0);
        }

        friend class AggregateExpr;

    public:
        typedef ptrdiff_t difference_type;
        typedef ComponentKey *value_type;
        typedef value_type pointer;
        typedef value_type &reference;
        typedef std::forward_iterator_tag iterator_category;

        bool operator ==(const KeyIterator &iter) const {
            return keyIdx == iter.keyIdx && listIdx == iter.listIdx;
        }

        bool operator !=(const KeyIterator &iter) const {
            return !this->operator==(iter);
        }

        KeyIterator &operator++() {
            listIdx = listIdx + 1;
            if (listIdx == keys[keyIdx]->numKeys()) {
                keyIdx = keyIdx + 1;
                listIdx = 0;
            }
            return *this;
        }

        KeyIterator operator++(int) {
            KeyIterator res = *this;
            this->operator++();
            return res;
        }

        reference operator*() {
            return keys[keyIdx]->getKey(listIdx);
        }

        pointer operator->() {
            return keys[keyIdx]->getKey(listIdx);
        }

        Expr *getExpr() { return keys[keyIdx]->getExpr(); }
    };

public:

    typedef KeyIterator key_iterator;
    key_iterator key_begin() { return KeyIterator(keyedComponents); }
    key_iterator key_end() {
        return KeyIterator::getSentinel(keyedComponents);
    }


    bool hasOthers() const { return others != 0; }



    Expr *getOthersExpr() { return others; }
    const Expr *getOthersExpr() const { return others; }

    Location getOthersLoc() const { return othersLoc; }

    void addOthersExpr(Location loc, Expr *component) {
        assert(!hasOthers() && "Others component already set!");
        othersLoc = loc;
        others = component;
    }

    void setOthersExpr(Expr *expr) {
        assert(hasOthers() &&
               "Cannot reset the others expr of this kind of aggregate!");
        others = expr;
    }

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

private:
    // Vector of expressions forming the positional components of this
    // aggregate.  Each positional component is considered to come before any
    // keyed or others components.
    std::vector<Expr*> positionalComponents;

    // Vector of ChoiceList's used to represent the keyed components of this
    // aggregate.  Keyed components come after any positional components.
    std::vector<ComponentKeyList*> keyedComponents;

    // Location of the "others" reserved word.
    Location othersLoc;

    // Expression associated with an "others" component or null if this
    // aggregate does not provide such a component.
    Expr *others;
};

} // end comma namespace.

#endif

---