RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 19:23:23 +01:00
Code Issues Projects Releases Wiki Activity

Provide a simpler interface for getting a ConstantArray from a character

Browse Source 
string. Instead of specifying the length, just specify whether the user
wants a terminating null or not. The default is "true" to retain the same
behavior as previously provided by this function.

llvm-svn: 28562
This commit is contained in:
Reid Spencer 2006-05-30 18:15:07 +00:00
parent ae1c91ec10
commit 1e1cfbb6fe
2 changed files with 10 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/llvm/Constants.h
View File

@ -347,12 +347,12 @@ public:
static Constant *get(const ArrayType *T, const std::vector<Constant*> &);
/// This method constructs a ConstantArray and initializes it with a text
/// string. The default behavior (len==0) causes the null terminator to
/// be copied as well. However, in some situations this is not desired so
/// if len <= Initializer.length() (but not 0) then only that portion of
/// the string is copied and there is no null termination. If len >
/// than Initializer's length then the function asserts out (don't do that).
static Constant *get(const std::string &Initializer, unsigned len = 0);
/// string. The default behavior (AddNull==true) causes a null terminator to
/// be placed at the end of the array. This effectively increases the length
/// of the array by one (you've been warned). However, in some situations
/// this is not desired so if AddNull==false then the string is copied without
/// null termination.
static Constant *get(const std::string &Initializer, bool AddNull = true);
/// getType - Specialize the getType() method to always return an ArrayType,
/// which reduces the amount of casting needed in parts of the compiler.

12
lib/VMCore/Constants.cpp
View File

@ -930,21 +930,17 @@ void ConstantArray::destroyConstant() {
/// Otherwise, the length parameter specifies how much of the string to use
/// and it won't be null terminated.
///
Constant *ConstantArray::get(const std::string &Str, unsigned length) {
assert(length <= Str.length() && "Invalid length for string");
Constant *ConstantArray::get(const std::string &Str, bool AddNull) {
std::vector<Constant*> ElementVals;
unsigned copy_len = (length == 0 ? Str.length() : length);
for (unsigned i = 0; i < copy_len; ++i)
for (unsigned i = 0; i < Str.length(); ++i)
ElementVals.push_back(ConstantSInt::get(Type::SByteTy, Str[i]));
// Add a null terminator to the string...
if (length == 0) {
if (AddNull) {
ElementVals.push_back(ConstantSInt::get(Type::SByteTy, 0));
copy_len++;
}
ArrayType *ATy = ArrayType::get(Type::SByteTy, copy_len);
ArrayType *ATy = ArrayType::get(Type::SByteTy, ElementVals.size());
return ConstantArray::get(ATy, ElementVals);
}