include/comma/ast/SubroutineRef.h

Go to the documentation of this file.

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

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

#ifndef COMMA_AST_SUBROUTINE_REF_HDR_GUARD
#define COMMA_AST_SUBROUTINE_REF_HDR_GUARD

#include "comma/ast/Decl.h"

namespace comma {

class SubroutineRef : public Ast {

    // The type used to represent the collection of referenced declarations.
    //
    // We use the smallest SmallVector we can since all SubroutineRefs are
    // eventually resolved to a single decl (when the program is well formed).
    typedef llvm::SmallVector<SubroutineDecl*, 1> DeclVector;

public:
    SubroutineRef(Location loc, SubroutineDecl *decl)
        : Ast(AST_SubroutineRef), loc(loc) {
        decls.push_back(decl);
    }

    SubroutineRef(Location loc, SubroutineDecl **decls, unsigned numDecls)
        : Ast(AST_SubroutineRef),
          decls(decls, decls + numDecls), loc(loc) {
        verify();
    }

    template <class I>
    SubroutineRef(Location loc, I begin, I end)
        : Ast(AST_SubroutineRef),
          decls(begin, end), loc(loc) {
        verify();
    }

    IdentifierInfo *getIdInfo() const {
        assert(!empty() && "Empty SubroutineRef!");
        return decls[0]->getIdInfo();
    }

    const char *getString() const { return getIdInfo()->getString(); }

    Location getLocation() const { return loc; }

    void addDeclaration(SubroutineDecl *srDecl);

    template <class Iter>
    void addDeclarations(Iter I, Iter E) {
        for ( ; I != E; ++I)
            addDeclaration(*I);
    }

    bool isOverloaded() const { return numDeclarations() > 1; }

    bool empty() const { return numDeclarations() == 0; }

    bool referencesFunctions() const {
        return empty() ? false : llvm::isa<FunctionDecl>(decls[0]);
    }

    bool referencesProcedures() const {
        return empty() ? false : llvm::isa<ProcedureDecl>(decls[0]);
    }

    unsigned numDeclarations() const { return decls.size(); }


    const SubroutineDecl *getDeclaration(unsigned i) const {
        assert(i < numDeclarations() && "Index out of range!");
        return decls[i];
    }

    SubroutineDecl *getDeclaration(unsigned i) {
        assert(i < numDeclarations() && "Index out of range!");
        return decls[i];
    }



    const SubroutineDecl *getDeclaration() const {
        return isResolved() ? decls[0] : 0;
    }

    SubroutineDecl *getDeclaration() {
        return isResolved() ? decls[0] : 0;
    }

    bool contains(const SubroutineDecl *srDecl) const;

    bool contains(const SubroutineType *srType) const;

    bool keepSubroutinesWithArity(unsigned arity);

    void resolve(SubroutineDecl *srDecl) {
        decls.clear();
        decls.push_back(srDecl);
    }

    bool isResolved() const { return numDeclarations() == 1; }


    typedef DeclVector::iterator iterator;
    iterator begin() { return decls.begin(); }
    iterator end() { return decls.end(); }

    typedef DeclVector::const_iterator const_iterator;
    const_iterator begin() const { return decls.begin(); }
    const_iterator end() const { return decls.end(); }

private:
    template <class T>
    class SubroutineDeclIter {

        mutable SubroutineRef::iterator I;

        SubroutineDeclIter(SubroutineRef::iterator I)
            : I(I) { }

        SubroutineRef::iterator getIterator() const { return I; }

        friend class SubroutineRef;

    public:
        SubroutineDeclIter(const SubroutineDeclIter<T> &iter)
            : I(iter.I) { }

        T *operator *() {
            return llvm::cast<T>(*I);
        }

        const T *operator *() const {
            return llvm::cast<T>(*I);
        }

        bool operator ==(const SubroutineDeclIter &iter) const {
            return this->I == iter.I;
        }

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

        SubroutineDeclIter &operator ++() {
            ++I;
            return *this;
        }

        const SubroutineDeclIter &operator ++() const {
            ++I;
            return *this;
        }

        SubroutineDeclIter operator ++(int) const {
            SubroutineDeclIter tmp = *this;
            this->operator++();
            return tmp;
        }
    };

public:






    typedef SubroutineDeclIter<FunctionDecl> fun_iterator;
    fun_iterator begin_functions() {
        if (this->referencesFunctions())
            return fun_iterator(begin());
        else
            return fun_iterator(end());
    }
    fun_iterator end_functions() {
        return fun_iterator(end());
    }

    typedef const SubroutineDeclIter<FunctionDecl> const_fun_iterator;
    const_fun_iterator begin_functions() const {
        SubroutineRef *ref = const_cast<SubroutineRef*>(this);
        if (this->referencesFunctions())
            return const_fun_iterator(ref->begin());
        else
            return const_fun_iterator(ref->end());
    }
    const_fun_iterator end_functions() const {
        SubroutineRef *ref = const_cast<SubroutineRef*>(this);
        return const_fun_iterator(ref->end());
    }

    typedef SubroutineDeclIter<ProcedureDecl> proc_iterator;
    proc_iterator begin_procedures() {
        if (this->referencesProcedures())
            return proc_iterator(begin());
        else
            return proc_iterator(end());
    }
    proc_iterator end_procedures() {
        return proc_iterator(end());
    }

    typedef const SubroutineDeclIter<ProcedureDecl> const_proc_iterator;
    const_proc_iterator begin_procedures() const {
        SubroutineRef *ref = const_cast<SubroutineRef*>(this);
        if (this->referencesProcedures())
            return const_proc_iterator(ref->begin());
        else
            return const_proc_iterator(ref->end());
    }
    const_proc_iterator end_procedures() const {
        SubroutineRef *ref = const_cast<SubroutineRef*>(this);
        return const_proc_iterator(ref->end());
    }


    iterator erase(iterator I) { return decls.erase(I); }

    template <class T>
    SubroutineDeclIter<T> erase(SubroutineDeclIter<T> SDI) {
        iterator I = SDI.getIterator();
        I = decls.erase(I);
        return SubroutineDeclIter<T>(I);
    }

    static bool classof(const SubroutineRef *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_SubroutineRef;
    }

private:
    DeclVector decls;
    Location loc;

    void verify();

    void verify(SubroutineDecl *decl, IdentifierInfo *name, bool isaFunction);
};

} // end comma namespace.

#endif

---