From: Chris Lattner Date: Mon, 26 Aug 2002 17:53:56 +0000 (+0000) Subject: Add support for turning an array of characters into a string. X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=93aeea3748b11fa213b345edf3c86275a4936a31;p=oota-llvm.git Add support for turning an array of characters into a string. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3509 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h index 82a5c1cfb21..63d1bfdd559 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -17,42 +17,42 @@ class PointerType; //===--------------------------------------------------------------------------- -// ConstantIntegral - Shared superclass of boolean and integer constants. -// -// This class just defines some common interfaces to be implemented. -// +/// ConstantIntegral - Shared superclass of boolean and integer constants. +/// +/// This class just defines some common interfaces to be implemented. +/// class ConstantIntegral : public Constant { protected: ConstantIntegral(const Type *Ty) : Constant(Ty) {} public: - // isNullValue - Return true if this is the value that would be returned by - // getNullValue. - // + /// isNullValue - Return true if this is the value that would be returned by + /// getNullValue. + /// virtual bool isNullValue() const = 0; - // isMaxValue - Return true if this is the largest value that may be - // represented by this type. - // + /// isMaxValue - Return true if this is the largest value that may be + /// represented by this type. + /// virtual bool isMaxValue() const = 0; - // isMinValue - Return true if this is the smallest value that may be - // represented by this type. - // + /// isMinValue - Return true if this is the smallest value that may be + /// represented by this type. + /// virtual bool isMinValue() const = 0; - // isAllOnesValue - Return true if every bit in this constant is set to true. - // + /// isAllOnesValue - Return true if every bit in this constant is set to true. + /// virtual bool isAllOnesValue() const = 0; - // Static constructor to get the maximum/minimum/allones constant of specified - // (integral) type... - // + /// Static constructor to get the maximum/minimum/allones constant of + /// specified (integral) type... + /// static ConstantIntegral *getMaxValue(const Type *Ty); static ConstantIntegral *getMinValue(const Type *Ty); static ConstantIntegral *getAllOnesValue(const Type *Ty); - // Methods for support type inquiry through isa, cast, and dyn_cast: + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantIntegral *) { return true; } static bool classof(const Constant *CPV); // defined in Constants.cpp static inline bool classof(const Value *V) { @@ -62,8 +62,8 @@ public: //===--------------------------------------------------------------------------- -// ConstantBool - Boolean Values -// +/// ConstantBool - Boolean Values +/// class ConstantBool : public ConstantIntegral { bool Val; ConstantBool(bool V); @@ -71,24 +71,26 @@ class ConstantBool : public ConstantIntegral { public: static ConstantBool *True, *False; // The True & False values - // Factory objects - Return objects of the specified value + /// get() - Static factory methods - Return objects of the specified value static ConstantBool *get(bool Value) { return Value ? True : False; } static ConstantBool *get(const Type *Ty, bool Value) { return get(Value); } - // inverted - Return the opposite value of the current value. + /// inverted - Return the opposite value of the current value. inline ConstantBool *inverted() const { return (this==True) ? False : True; } + /// getValue - return the boolean value of this constant. + /// inline bool getValue() const { return Val; } - // isNullValue - Return true if this is the value that would be returned by - // getNullValue. - // + /// isNullValue - Return true if this is the value that would be returned by + /// getNullValue. + /// virtual bool isNullValue() const { return this == False; } virtual bool isMaxValue() const { return this == True; } virtual bool isMinValue() const { return this == False; } virtual bool isAllOnesValue() const { return this == True; } - // Methods for support type inquiry through isa, cast, and dyn_cast: + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantBool *) { return true; } static bool classof(const Constant *CPV) { return (CPV == True) | (CPV == False); @@ -100,9 +102,9 @@ public: //===--------------------------------------------------------------------------- -// ConstantInt - Superclass of ConstantSInt & ConstantUInt, to make dealing -// with integral constants easier. -// +/// ConstantInt - Superclass of ConstantSInt & ConstantUInt, to make dealing +/// with integral constants easier. +/// class ConstantInt : public ConstantIntegral { protected: union { @@ -113,29 +115,30 @@ protected: ConstantInt(const Type *Ty, uint64_t V); ~ConstantInt() {} public: - // equalsInt - Provide a helper method that can be used to determine if the - // constant contained within is equal to a constant. This only works for very - // small values, because this is all that can be represented with all types. - // + /// equalsInt - Provide a helper method that can be used to determine if the + /// constant contained within is equal to a constant. This only works for + /// very small values, because this is all that can be represented with all + /// types. + /// bool equalsInt(unsigned char V) const { assert(V <= 127 && "equals: Can only be used with very small positive constants!"); return Val.Unsigned == V; } - // ConstantInt::get static method: return a constant pool int with the - // specified value. as above, we work only with very small values here. - // + /// ConstantInt::get static method: return a ConstantInt with the specified + /// value. as above, we work only with very small values here. + /// static ConstantInt *get(const Type *Ty, unsigned char V); - // isNullValue - Return true if this is the value that would be returned by - // getNullValue. + /// isNullValue - Return true if this is the value that would be returned by + /// getNullValue. virtual bool isNullValue() const { return Val.Unsigned == 0; } virtual bool isAllOnesValue() const { return Val.Signed == -1; } virtual bool isMaxValue() const = 0; virtual bool isMinValue() const = 0; - // Methods for support type inquiry through isa, cast, and dyn_cast: + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantInt *) { return true; } static bool classof(const Constant *CPV); // defined in Constants.cpp static inline bool classof(const Value *V) { @@ -145,22 +148,26 @@ public: //===--------------------------------------------------------------------------- -// ConstantSInt - Signed Integer Values [sbyte, short, int, long] -// +/// ConstantSInt - Signed Integer Values [sbyte, short, int, long] +/// class ConstantSInt : public ConstantInt { ConstantSInt(const ConstantSInt &); // DO NOT IMPLEMENT protected: ConstantSInt(const Type *Ty, int64_t V); ~ConstantSInt() {} public: + /// get() - Static factory methods - Return objects of the specified value static ConstantSInt *get(const Type *Ty, int64_t V); + /// isValueValidForType - return true if Ty is big enough to represent V. static bool isValueValidForType(const Type *Ty, int64_t V); + + /// getValue - return the underlying value of this constant. inline int64_t getValue() const { return Val.Signed; } - // isMaxValue - Return true if this is the largest value that may be - // represented by this type. - // + /// isMaxValue - Return true if this is the largest value that may be + /// represented by this type. + /// virtual bool isMaxValue() const { int64_t V = getValue(); if (V < 0) return false; // Be careful about wrap-around on 'long's @@ -168,9 +175,9 @@ public: return !isValueValidForType(getType(), V) || V < 0; } - // isMinValue - Return true if this is the smallest value that may be - // represented by this type. - // + /// isMinValue - Return true if this is the smallest value that may be + /// represented by this type. + /// virtual bool isMinValue() const { int64_t V = getValue(); if (V > 0) return false; // Be careful about wrap-around on 'long's @@ -178,7 +185,7 @@ public: return !isValueValidForType(getType(), V) || V > 0; } - // Methods for support type inquiry through isa, cast, and dyn_cast: + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantSInt *) { return true; } static bool classof(const Constant *CPV); // defined in Constants.cpp static inline bool classof(const Value *V) { @@ -187,26 +194,30 @@ public: }; //===--------------------------------------------------------------------------- -// ConstantUInt - Unsigned Integer Values [ubyte, ushort, uint, ulong] -// +/// ConstantUInt - Unsigned Integer Values [ubyte, ushort, uint, ulong] +/// class ConstantUInt : public ConstantInt { ConstantUInt(const ConstantUInt &); // DO NOT IMPLEMENT protected: ConstantUInt(const Type *Ty, uint64_t V); ~ConstantUInt() {} public: + /// get() - Static factory methods - Return objects of the specified value static ConstantUInt *get(const Type *Ty, uint64_t V); + /// isValueValidForType - return true if Ty is big enough to represent V. static bool isValueValidForType(const Type *Ty, uint64_t V); + + /// getValue - return the underlying value of this constant. inline uint64_t getValue() const { return Val.Unsigned; } - // isMaxValue - Return true if this is the largest value that may be - // represented by this type. - // + /// isMaxValue - Return true if this is the largest value that may be + /// represented by this type. + /// virtual bool isMaxValue() const { return isAllOnesValue(); } virtual bool isMinValue() const { return getValue() == 0; } - // Methods for support type inquiry through isa, cast, and dyn_cast: + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantUInt *) { return true; } static bool classof(const Constant *CPV); // defined in Constants.cpp static inline bool classof(const Value *V) { @@ -216,8 +227,8 @@ public: //===--------------------------------------------------------------------------- -// ConstantFP - Floating Point Values [float, double] -// +/// ConstantFP - Floating Point Values [float, double] +/// class ConstantFP : public Constant { double Val; ConstantFP(const ConstantFP &); // DO NOT IMPLEMENT @@ -225,16 +236,18 @@ protected: ConstantFP(const Type *Ty, double V); ~ConstantFP() {} public: + /// get() - Static factory methods - Return objects of the specified value static ConstantFP *get(const Type *Ty, double V); + /// isValueValidForType - return true if Ty is big enough to represent V. static bool isValueValidForType(const Type *Ty, double V); inline double getValue() const { return Val; } - // isNullValue - Return true if this is the value that would be returned by - // getNullValue. + /// isNullValue - Return true if this is the value that would be returned by + /// getNullValue. virtual bool isNullValue() const { return Val == 0; } - // Methods for support type inquiry through isa, cast, and dyn_cast: + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantFP *) { return true; } static bool classof(const Constant *CPV); // defined in Constants.cpp static inline bool classof(const Value *V) { @@ -244,8 +257,8 @@ public: //===--------------------------------------------------------------------------- -// ConstantArray - Constant Array Declarations -// +/// ConstantArray - Constant Array Declarations +/// class ConstantArray : public Constant { ConstantArray(const ConstantArray &); // DO NOT IMPLEMENT protected: @@ -253,22 +266,34 @@ protected: ~ConstantArray() {} public: + /// get() - Static factory methods - Return objects of the specified value static ConstantArray *get(const ArrayType *T, const std::vector &); static ConstantArray *get(const std::string &Initializer); + /// getType - Specialize the getType() method to always return an ArrayType, + /// which reduces the amount of casting needed in parts of the compiler. + /// inline const ArrayType *getType() const { return (ArrayType*)Value::getType(); } + /// getAsString - If the sub-element type of this array is either sbyte or + /// ubyte, then this method converts the array to an std::string and returns + /// it. Otherwise, it asserts out. + /// + std::string getAsString() const; + + /// getValues - Return a vector of the component constants that make up this + /// array. inline const std::vector &getValues() const { return Operands; } - // isNullValue - Return true if this is the value that would be returned by - // getNullValue. + /// isNullValue - Return true if this is the value that would be returned by + /// getNullValue. virtual bool isNullValue() const { return false; } virtual void destroyConstant(); - // Methods for support type inquiry through isa, cast, and dyn_cast: + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantArray *) { return true; } static bool classof(const Constant *CPV); // defined in Constants.cpp static inline bool classof(const Value *V) { @@ -287,22 +312,26 @@ protected: ~ConstantStruct() {} public: + /// get() - Static factory methods - Return objects of the specified value static ConstantStruct *get(const StructType *T, const std::vector &V); + /// getType() specialization - Reduce amount of casting... inline const StructType *getType() const { return (StructType*)Value::getType(); } + /// getValues - Return a vector of the component constants that make up this + /// structure. inline const std::vector &getValues() const { return Operands; } - // isNullValue - Return true if this is the value that would be returned by - // getNullValue. + /// isNullValue - Return true if this is the value that would be returned by + /// getNullValue. virtual bool isNullValue() const { return false; } virtual void destroyConstant(); - - // Methods for support type inquiry through isa, cast, and dyn_cast: + + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantStruct *) { return true; } static bool classof(const Constant *CPV); // defined in Constants.cpp static inline bool classof(const Value *V) { @@ -311,12 +340,12 @@ public: }; //===--------------------------------------------------------------------------- -// ConstantPointer - Constant Pointer Declarations -// -// The ConstantPointer class represents a null pointer of a specific type. For -// a more specific/useful instance, a subclass of ConstantPointer should be -// used. -// +/// ConstantPointer - Constant Pointer Declarations +/// +/// The ConstantPointer class represents a null pointer of a specific type. For +/// a more specific/useful instance, a subclass of ConstantPointer should be +/// used. +/// class ConstantPointer : public Constant { ConstantPointer(const ConstantPointer &); // DO NOT IMPLEMENT protected: @@ -327,11 +356,11 @@ public: return (PointerType*)Value::getType(); } - // isNullValue - Return true if this is the value that would be returned by - // getNullValue. + /// isNullValue - Return true if this is the value that would be returned by + /// getNullValue. virtual bool isNullValue() const { return false; } - // Methods for support type inquiry through isa, cast, and dyn_cast: + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantPointer *) { return true; } static bool classof(const Constant *CPV); // defined in Constants.cpp static inline bool classof(const Value *V) { @@ -339,8 +368,8 @@ public: } }; -// ConstantPointerNull - a constant pointer value that points to null -// +/// ConstantPointerNull - a constant pointer value that points to null +/// class ConstantPointerNull : public ConstantPointer { ConstantPointerNull(const ConstantPointerNull &); // DO NOT IMPLEMENT protected: @@ -348,15 +377,16 @@ protected: inline ~ConstantPointerNull() {} public: + /// get() - Static factory methods - Return objects of the specified value static ConstantPointerNull *get(const PointerType *T); - // isNullValue - Return true if this is the value that would be returned by - // getNullValue. + /// isNullValue - Return true if this is the value that would be returned by + /// getNullValue. virtual bool isNullValue() const { return true; } virtual void destroyConstant(); - // Methods for support type inquiry through isa, cast, and dyn_cast: + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantPointerNull *) { return true; } static inline bool classof(const ConstantPointer *P) { return (P->getNumOperands() == 0 && P->isNullValue()); @@ -370,9 +400,9 @@ public: }; -// ConstantPointerRef - a constant pointer value that is initialized to -// point to a global value, which lies at a constant, fixed address. -// +/// ConstantPointerRef - a constant pointer value that is initialized to +/// point to a global value, which lies at a constant, fixed address. +/// class ConstantPointerRef : public ConstantPointer { friend class Module; // Modules maintain these references ConstantPointerRef(const ConstantPointerRef &); // DNI! @@ -381,18 +411,20 @@ protected: ConstantPointerRef(GlobalValue *GV); ~ConstantPointerRef() {} public: + /// get() - Static factory methods - Return objects of the specified value static ConstantPointerRef *get(GlobalValue *GV); const GlobalValue *getValue() const { return cast(Operands[0].get()); } + GlobalValue *getValue() { return cast(Operands[0].get()); } virtual void destroyConstant(); - // Methods for support type inquiry through isa, cast, and dyn_cast: + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantPointerRef *) { return true; } static inline bool classof(const ConstantPointer *CPV) { // check for a single operand (the target value) @@ -433,32 +465,32 @@ protected: public: // Static methods to construct a ConstantExpr of different kinds. - // Cast constant expr + /// Cast constant expr static ConstantExpr *getCast(Constant *C, const Type *Ty); - // Binary constant expr - Use with binary operators... + /// Binary constant expr - Use with binary operators... static ConstantExpr *get(unsigned Opcode, Constant *C1, Constant *C2); - // Getelementptr form... + /// Getelementptr form... static ConstantExpr *getGetElementPtr(Constant *C, const std::vector &IdxList); - // isNullValue - Return true if this is the value that would be returned by - // getNullValue. + /// isNullValue - Return true if this is the value that would be returned by + /// getNullValue. virtual bool isNullValue() const { return false; } - // getOpcode - Return the opcode at the root of this constant expression + /// getOpcode - Return the opcode at the root of this constant expression unsigned getOpcode() const { return iType; } - // getOpcodeName - Return a string representation for an opcode. + /// getOpcodeName - Return a string representation for an opcode. const char *getOpcodeName() const; - // isConstantExpr - Return true if this is a ConstantExpr + /// isConstantExpr - Return true if this is a ConstantExpr virtual bool isConstantExpr() const { return true; } virtual void destroyConstant(); - // Methods for support type inquiry through isa, cast, and dyn_cast: + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantExpr *) { return true; } static inline bool classof(const Constant *CPV) { return CPV->isConstantExpr(); diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 98df6ea4b79..40c714ec82d 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -422,6 +422,24 @@ void ConstantArray::destroyConstant() { destroyConstantImpl(); } +// getAsString - If the sub-element type of this array is either sbyte or ubyte, +// then this method converts the array to an std::string and returns it. +// Otherwise, it asserts out. +// +std::string ConstantArray::getAsString() const { + std::string Result; + if (getType()->getElementType() == Type::SByteTy) + for (unsigned i = 0, e = getNumOperands(); i != e; ++i) + Result += (char)cast(getOperand(i))->getValue(); + else { + assert(getType()->getElementType() == Type::UByteTy && "Not a string!"); + for (unsigned i = 0, e = getNumOperands(); i != e; ++i) + Result += (char)cast(getOperand(i))->getValue(); + } + return Result; +} + + //---- ConstantStruct::get() implementation... // static ValueMap, ConstantStruct> StructConstants;