include/comma/ast/Pragma.h

Go to the documentation of this file.

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

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

#ifndef COMMA_AST_PRAGMA_HDR_GUARD
#define COMMA_AST_PRAGMA_HDR_GUARD

#include "comma/ast/AstBase.h"
#include "comma/basic/Pragmas.h"

#include "llvm/ADT/ilist.h"
#include "llvm/ADT/StringRef.h"

namespace comma {

//===----------------------------------------------------------------------===//
// Pragma
class Pragma {

public:
    virtual ~Pragma() { }

    pragma::PragmaID getKind() const { return ID; }

    Location getLocation() const { return loc; }



    Pragma *getNext() { return nextLink; }
    Pragma *getPrev() { return prevLink; }

    const Pragma *getNext() const { return nextLink; }
    const Pragma *getPrev() const { return prevLink; }

    void setNext(Pragma *P) { nextLink = P; }
    void setPrev(Pragma *P) { prevLink = P; }

    // Support isa and dyn_cast.
    static bool classof(const Pragma *pragma) { return true; }

protected:
    Pragma(pragma::PragmaID ID, Location loc)
        : ID(ID), loc(loc), nextLink(0), prevLink(0) { }

    Pragma() : ID(pragma::UNKNOWN_PRAGMA), loc(0), nextLink(0), prevLink(0) { }
    friend class llvm::ilist_sentinel_traits<Pragma>;

    pragma::PragmaID ID;
    Location loc;
    Pragma *nextLink;
    Pragma *prevLink;
};

//===----------------------------------------------------------------------===//
// PragmaAssert
class PragmaAssert : public Pragma {

public:
    PragmaAssert(Location loc, Expr *condition, Expr *message = 0)
        : Pragma(pragma::Assert, loc),
          condition(condition),
          message(message) { }


    const Expr *getCondition() const { return condition; }
    Expr *getCondition() { return condition; }



    const Expr *getMessage() const { return message; }
    Expr *getMessage() { return message; }

    bool hasMessage() const { return message != 0; }

    void setCondition(Expr *condition) { this->condition = condition; }

    void setMessage(Expr *message) { this->message = message; }

    // Support isa and dyn_cast.
    static bool classof(const PragmaAssert *pragma) { return true; }
    static bool classof(const Pragma *pragma) {
        return pragma->getKind() == pragma::Assert;
    }

private:
    Expr *condition;
    Expr *message;
};

//===----------------------------------------------------------------------===//
// PragmaImport
class PragmaImport : public Pragma {

public:
    enum Convention {
        UNKNOWN_CONVENTION,
        C
    };

    PragmaImport(Location loc, Convention convention,
                 IdentifierInfo *entity, Expr *externalName);

    static Convention getConventionID(llvm::StringRef &ref);

    Convention getConvention() const { return convention; }

    IdentifierInfo *getEntityIdInfo() const { return entity; }



    Expr *getExternalNameExpr() { return externalNameExpr; }
    const Expr *getExternalNameExpr() const { return externalNameExpr; }

    const std::string &getExternalName() const { return externalName; }

private:
    Convention convention;
    IdentifierInfo *entity;
    Expr *externalNameExpr;
    std::string externalName;
};

} // end comma namespace.

#endif

---