| //===-- AST Constant Values -------------------------------------*- C++ -*-===// |
| // |
| // High Level Virtual Machine (HLVM) |
| // |
| // Copyright (C) 2006 Reid Spencer. All Rights Reserved. |
| // |
| // This software is free software; you can redistribute it and/or modify it |
| // under the terms of the GNU Lesser General Public License as published by |
| // the Free Software Foundation; either version 2.1 of the License, or (at |
| // your option) any later version. |
| // |
| // This software is distributed in the hope that it will be useful, but WITHOUT |
| // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
| // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for |
| // more details. |
| // |
| // You should have received a copy of the GNU Lesser General Public License |
| // along with this library in the file named LICENSE.txt; if not, write to the |
| // Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
| // MA 02110-1301 USA |
| // |
| //===----------------------------------------------------------------------===// |
| /// @file hlvm/AST/Constants.h |
| /// @author Reid Spencer <rspencer@reidspencer.com> (original author) |
| /// @date 2006/05/25 |
| /// @since 0.1.0 |
| /// @brief Declares the AST Constant Expression Operators |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef HLVM_AST_CONSTANTS_H |
| #define HLVM_AST_CONSTANTS_H |
| |
| #include <hlvm/AST/Node.h> |
| |
| namespace hlvm |
| { |
| |
| /// This abstract base class represents a constant value in the HLVM Abstract |
| /// Syntax Tree. All Constants are immutable values of a specific type. |
| /// Constants do not have a storage location nor an address nor do they |
| /// participate in linking. However, as they are values they may be used as |
| /// the operand of instructions or as the initializers of variables. Constants |
| /// do not participate in linking and are always internal to the bundle in which |
| /// they appear. To create a linkable constant, declare a variable that is |
| /// constant and initialize it with a Constant. There are many kinds of |
| /// constants including simple literal values (numbers an text), complex |
| /// constant expressions (constant computations), and aggregate constants that |
| /// represent constant arrays, vectors, pointers and structures. |
| /// @see hlvm/AST/Constants.h |
| /// @brief AST Abstract Constant Node |
| class Constant : public Value |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| Constant(NodeIDs id) : Value(id), name() {} |
| virtual ~Constant(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| /// Get the name of the Constant |
| const std::string& getName() const { return name; } |
| bool hasName() const { return !name.empty(); } |
| static inline bool classof(const Constant*) { return true; } |
| static inline bool classof(const Node* N) { return N->isConstant(); } |
| |
| /// @} |
| /// @name Mutators |
| /// @{ |
| public: |
| /// Set the name of the Constant |
| void setName(const std::string& n) { name = n; } |
| |
| /// @} |
| /// @name Data |
| /// @{ |
| protected: |
| std::string name; ///< The name of this value. |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This is an abstract base class in the Abstract Syntax Tree that represents |
| /// a constant value used in the program. |
| /// @brief AST Constant Value Node |
| class ConstantValue: public Constant |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantValue(NodeIDs id) : Constant(id) {} |
| virtual ~ConstantValue(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const ConstantValue*) { return true; } |
| static inline bool classof(const Node* N) { return N->isConstantValue(); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a |
| /// constant any value. |
| /// @brief AST Constant Any Value Node |
| class ConstantAny: public ConstantValue |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantAny(ConstantValue* val) : ConstantValue(ConstantAnyID) { |
| value = val; } |
| virtual ~ConstantAny(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| ConstantValue* getValue() const { return value; } |
| static inline bool classof(const ConstantAny*) { return true; } |
| static inline bool classof(const Node* N) |
| { return N->is(ConstantAnyID); } |
| |
| /// @} |
| /// @name Data |
| /// @{ |
| private: |
| ConstantValue* value; |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a |
| /// constant boolean value. |
| /// @brief AST Constant Boolean Node |
| class ConstantBoolean: public ConstantValue |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantBoolean(bool val) : ConstantValue(ConstantBooleanID) { |
| flags = val; } |
| virtual ~ConstantBoolean(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| bool getValue() const { return flags != 0; } |
| static inline bool classof(const ConstantBoolean*) { return true; } |
| static inline bool classof(const Node* N) |
| { return N->is(ConstantBooleanID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a |
| /// constant character value. |
| /// @brief AST Constant Character Node |
| class ConstantCharacter: public ConstantValue |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantCharacter(const std::string& val) |
| : ConstantValue(ConstantCharacterID) { value = val; } |
| virtual ~ConstantCharacter(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| const std::string& getValue() const { return value; } |
| static inline bool classof(const ConstantCharacter*) { return true; } |
| static inline bool classof(const Node* N) |
| { return N->is(ConstantCharacterID); } |
| |
| /// @} |
| /// @name Data |
| /// @{ |
| public: |
| std::string value; |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a |
| /// constant octet value. |
| /// @brief AST Constant Octet Node |
| class ConstantEnumerator: public ConstantValue |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantEnumerator(const std::string& val) |
| : ConstantValue(ConstantEnumeratorID) { value = val; } |
| virtual ~ConstantEnumerator(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| const std::string& getValue() const { return value; } |
| static inline bool classof(const ConstantEnumerator*) { return true; } |
| static inline bool classof(const Node* N) |
| { return N->is(ConstantEnumeratorID); } |
| |
| /// @} |
| /// @name Data |
| /// @{ |
| public: |
| std::string value; |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a |
| /// constant integer value. This kind of constant can represent integer valued |
| /// constants of any of the signed or unsigned integer types of any bitsize. |
| /// @see IntegerType |
| /// @brief AST Constant Integer Node |
| class ConstantInteger: public ConstantValue |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantInteger(uint16_t base) : ConstantValue(ConstantIntegerID) {} |
| virtual ~ConstantInteger(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| const std::string& getValue() const { return value; } |
| uint16_t getBase() const { return flags; } |
| static inline bool classof(const ConstantInteger*) { return true; } |
| static inline bool classof(const Node* N) |
| { return N->is(ConstantIntegerID); } |
| |
| /// @} |
| /// @name Mutators |
| /// @{ |
| public: |
| void setValue(const std::string& v) { value = v; } |
| void setBase(uint16_t base) { flags = base; } |
| |
| /// @} |
| /// @name Data |
| /// @{ |
| public: |
| std::string value; |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a constant |
| /// real number value. This kind of constant can represent a constant real |
| /// number value of any mantissa or exponent size. |
| /// @see RealType |
| /// @brief AST Constant Real Node |
| class ConstantReal : public ConstantValue |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantReal() : ConstantValue(ConstantRealID) {} |
| virtual ~ConstantReal(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| const std::string& getValue() const { return value; } |
| static inline bool classof(const ConstantReal*) { return true; } |
| static inline bool classof(const Node* N) |
| { return N->is(ConstantRealID); } |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| void setValue(const std::string& v ) { value = v; } |
| |
| /// @} |
| /// @name Data |
| /// @{ |
| public: |
| std::string value; |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a constant |
| /// string value. The constant value is encoded in UTF-8 with a null terminator. |
| /// @see StringType |
| /// @brief AST Constant String Node |
| class ConstantString : public ConstantValue |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantString() : ConstantValue(ConstantStringID) {} |
| virtual ~ConstantString(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| const std::string& getValue() const{ return value; } |
| static inline bool classof(const ConstantString*) { return true; } |
| static inline bool classof(const Node* N) |
| { return N->is(ConstantStringID); } |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| void setValue(const std::string& v ) { value = v; } |
| |
| /// @} |
| /// @name Data |
| /// @{ |
| public: |
| std::string value; |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a constant |
| /// pointer value. |
| /// @brief AST Constant Pointer Node |
| class ConstantPointer : public ConstantValue |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantPointer(const Constant* cv) |
| : ConstantValue(ConstantPointerID) { value = cv; } |
| virtual ~ConstantPointer(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| const Constant* getValue() const { return value; } |
| static inline bool classof(const ConstantPointer*) { return true; } |
| static inline bool classof(const Node* N) |
| { return N->is(ConstantPointerID); } |
| |
| /// @} |
| /// @name Data |
| /// @{ |
| public: |
| const Constant* value; |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a constant |
| /// aggregate. This can be used to specify constant values of aggregate types |
| /// such as arrays, vectors, structures and continuations. It simply contains |
| /// a list of other elements which themselves must be constants. |
| /// @brief AST Constant Array Node. |
| class ConstantAggregate : public ConstantValue |
| { |
| /// @name Types |
| /// @{ |
| public: |
| typedef std::vector<const ConstantValue*> ElementsList; |
| typedef ElementsList::iterator iterator; |
| typedef ElementsList::const_iterator const_iterator; |
| |
| /// @} |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantAggregate(NodeIDs id) : ConstantValue(id), elems() {} |
| virtual ~ConstantAggregate(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const ConstantAggregate*) { return true; } |
| static inline bool classof(const Node* N) |
| { return N->isConstantAggregate(); } |
| |
| /// @} |
| /// @name Mutators |
| /// @{ |
| public: |
| void addConstant(const ConstantValue* val) { elems.push_back(val); } |
| |
| protected: |
| virtual void insertChild(Node* n); |
| virtual void removeChild(Node* n); |
| |
| /// @} |
| /// @name Iterators |
| /// @{ |
| public: |
| iterator begin() { return elems.begin(); } |
| const_iterator begin() const { return elems.begin(); } |
| iterator end () { return elems.end(); } |
| const_iterator end () const { return elems.end(); } |
| size_t size () const { return elems.size(); } |
| bool empty() const { return elems.empty(); } |
| const ConstantValue* front() const { return elems.front(); } |
| const ConstantValue* back() const { return elems.back(); } |
| |
| /// @} |
| /// @name Data |
| /// @{ |
| protected: |
| ElementsList elems; ///< The contained types |
| /// @} |
| |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a constant |
| /// array value. |
| /// @brief AST Constant Array Node |
| class ConstantArray : public ConstantAggregate |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantArray() : ConstantAggregate(ConstantArrayID) {} |
| virtual ~ConstantArray(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| const Type* getElementType() const; |
| static inline bool classof(const ConstantArray*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(ConstantArrayID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a constant |
| /// array value. |
| /// @brief AST Constant Vector Node |
| class ConstantVector : public ConstantAggregate |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantVector() : ConstantAggregate(ConstantVectorID) {} |
| virtual ~ConstantVector(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const ConstantVector*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(ConstantVectorID);} |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a constant |
| /// array value. |
| /// @brief AST Constant Vector Node |
| class ConstantStructure : public ConstantAggregate |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantStructure() : ConstantAggregate(ConstantStructureID) {} |
| virtual ~ConstantStructure(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const ConstantStructure*) { return true; } |
| static inline bool classof(const Node* N) { |
| return N->is(ConstantStructureID); |
| } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a constant |
| /// continuation value. |
| /// @brief AST Constant Vector Node |
| class ConstantContinuation : public ConstantAggregate |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantContinuation() : ConstantAggregate(ConstantContinuationID) {} |
| virtual ~ConstantContinuation(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const ConstantContinuation*) { return true; } |
| static inline bool classof(const Node* N) { |
| return N->is(ConstantContinuationID); |
| } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that yields a constant |
| /// expression. The expression uses a limited set of operator identifiers that |
| /// can yield constants such as arithmetic or comparison operators. |
| /// @brief AST Constant Expression Node. |
| class ConstantExpression : public ConstantValue |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| ConstantExpression(NodeIDs exprOp) : ConstantValue(ConstantExpressionID) |
| { flags = exprOp; } |
| virtual ~ConstantExpression(); |
| public: |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const ConstantExpression*) { return true; } |
| static inline bool classof(const Node* N) |
| { return N->is(ConstantExpressionID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| } // end hlvm namespace |
| |
| #endif |