#include "il2cpp-config.h"
|
#include <memory>
|
#include "il2cpp-api.h"
|
#include "il2cpp-object-internals.h"
|
#include "il2cpp-class-internals.h"
|
#include "icalls/mscorlib/System/String.h"
|
#include "utils/StringUtils.h"
|
#include "vm/Array.h"
|
#include "vm/Class.h"
|
#include "vm/String.h"
|
#include "vm/Exception.h"
|
|
namespace il2cpp
|
{
|
namespace icalls
|
{
|
namespace mscorlib
|
{
|
namespace System
|
{
|
void String::RedirectToCreateString()
|
{
|
NOT_SUPPORTED_IL2CPP(String::RedirectToCreateString, "All String constructors should be redirected to String.CreateString.");
|
}
|
|
Il2CppString * String::InternalAllocateStr(int length)
|
{
|
return il2cpp::vm::String::NewSize(length);
|
}
|
|
static bool
|
string_icall_is_in_array(Il2CppArray *chars, int32_t arraylength, Il2CppChar chr)
|
{
|
Il2CppChar cmpchar;
|
int32_t arrpos;
|
|
for (arrpos = 0; arrpos != arraylength; arrpos++)
|
{
|
cmpchar = il2cpp_array_get(chars, Il2CppChar, arrpos);
|
if (cmpchar == chr)
|
return true;
|
}
|
|
return false;
|
}
|
|
/* System.StringSplitOptions */
|
typedef enum
|
{
|
STRINGSPLITOPTIONS_NONE = 0,
|
STRINGSPLITOPTIONS_REMOVE_EMPTY_ENTRIES = 1
|
} StringSplitOptions;
|
|
Il2CppArray * String::InternalSplit(Il2CppString* me, Il2CppArray* separator, int count, int options)
|
{
|
static Il2CppClass *String_array;
|
Il2CppString * tmpstr;
|
Il2CppArray * retarr;
|
Il2CppChar *src;
|
int32_t arrsize, srcsize, splitsize;
|
int32_t i, lastpos, arrpos;
|
int32_t tmpstrsize;
|
int32_t remempty;
|
int32_t flag;
|
Il2CppChar *tmpstrptr;
|
|
remempty = options & STRINGSPLITOPTIONS_REMOVE_EMPTY_ENTRIES;
|
src = il2cpp::utils::StringUtils::GetChars(me);
|
srcsize = il2cpp::utils::StringUtils::GetLength(me);
|
arrsize = il2cpp::vm::Array::GetLength(separator);
|
|
if (!String_array)
|
{
|
Il2CppClass *klass = il2cpp::vm::Class::GetArrayClass(il2cpp_defaults.string_class, 1);
|
//mono_memory_barrier ();
|
String_array = klass;
|
}
|
|
splitsize = 1;
|
/* Count the number of elements we will return. Note that this operation
|
* guarantees that we will return exactly splitsize elements, and we will
|
* have enough data to fill each. This allows us to skip some checks later on.
|
*/
|
if (remempty == 0)
|
{
|
for (i = 0; i != srcsize && splitsize < count; i++)
|
{
|
if (string_icall_is_in_array(separator, arrsize, src[i]))
|
splitsize++;
|
}
|
}
|
else if (count > 1)
|
{
|
/* Require pattern "Nondelim + Delim + Nondelim" to increment counter.
|
* Lastpos != 0 means first nondelim found.
|
* Flag = 0 means last char was delim.
|
* Efficient, though perhaps confusing.
|
*/
|
lastpos = 0;
|
flag = 0;
|
for (i = 0; i != srcsize && splitsize < count; i++)
|
{
|
if (string_icall_is_in_array(separator, arrsize, src[i]))
|
{
|
flag = 0;
|
}
|
else if (flag == 0)
|
{
|
if (lastpos == 1)
|
splitsize++;
|
flag = 1;
|
lastpos = 1;
|
}
|
}
|
|
/* Nothing but separators */
|
if (lastpos == 0)
|
{
|
retarr = il2cpp::vm::Array::NewSpecific(String_array, 0);
|
return retarr;
|
}
|
}
|
|
/* if no split chars found return the string */
|
if (splitsize == 1)
|
{
|
if (remempty == 0 || count == 1)
|
{
|
/* Copy the whole string */
|
retarr = il2cpp::vm::Array::NewSpecific(String_array, 1);
|
il2cpp_array_setref(retarr, 0, me);
|
}
|
else
|
{
|
/* otherwise we have to filter out leading & trailing delims */
|
|
/* find first non-delim char */
|
for (; srcsize != 0; srcsize--, src++)
|
{
|
if (!string_icall_is_in_array(separator, arrsize, src[0]))
|
break;
|
}
|
/* find last non-delim char */
|
for (; srcsize != 0; srcsize--)
|
{
|
if (!string_icall_is_in_array(separator, arrsize, src[srcsize - 1]))
|
break;
|
}
|
tmpstr = il2cpp::vm::String::NewSize(srcsize);
|
tmpstrptr = il2cpp::utils::StringUtils::GetChars(tmpstr);
|
|
memcpy(tmpstrptr, src, srcsize * sizeof(Il2CppChar));
|
retarr = il2cpp::vm::Array::NewSpecific(String_array, 1);
|
il2cpp_array_setref(retarr, 0, tmpstr);
|
}
|
return retarr;
|
}
|
|
lastpos = 0;
|
arrpos = 0;
|
|
retarr = il2cpp::vm::Array::NewSpecific(String_array, splitsize);
|
|
for (i = 0; i != srcsize && arrpos != splitsize; i++)
|
{
|
if (string_icall_is_in_array(separator, arrsize, src[i]))
|
{
|
if (lastpos != i || remempty == 0)
|
{
|
tmpstrsize = i - lastpos;
|
tmpstr = il2cpp::vm::String::NewSize(tmpstrsize);
|
tmpstrptr = il2cpp::utils::StringUtils::GetChars(tmpstr);
|
|
memcpy(tmpstrptr, src + lastpos, tmpstrsize * sizeof(Il2CppChar));
|
il2cpp_array_setref(retarr, arrpos, tmpstr);
|
arrpos++;
|
|
if (arrpos == splitsize - 1)
|
{
|
/* Shortcut the last array element */
|
|
lastpos = i + 1;
|
if (remempty != 0)
|
{
|
/* Search for non-delim starting char (guaranteed to find one) Note that loop
|
* condition is only there for safety. It will never actually terminate the loop. */
|
for (; lastpos != srcsize; lastpos++)
|
{
|
if (!string_icall_is_in_array(separator, arrsize, src[lastpos]))
|
break;
|
}
|
if (count > splitsize)
|
{
|
/* Since we have fewer results than our limit, we must remove
|
* trailing delimiters as well.
|
*/
|
for (; srcsize != lastpos + 1; srcsize--)
|
{
|
if (!string_icall_is_in_array(separator, arrsize, src[srcsize - 1]))
|
break;
|
}
|
}
|
}
|
|
tmpstrsize = srcsize - lastpos;
|
tmpstr = il2cpp::vm::String::NewSize(tmpstrsize);
|
tmpstrptr = il2cpp::utils::StringUtils::GetChars(tmpstr);
|
|
memcpy(tmpstrptr, src + lastpos, tmpstrsize * sizeof(Il2CppChar));
|
il2cpp_array_setref(retarr, arrpos, tmpstr);
|
|
/* Loop will ALWAYS end here. Test criteria in the FOR loop is technically unnecessary. */
|
break;
|
}
|
}
|
lastpos = i + 1;
|
}
|
}
|
|
return retarr;
|
}
|
|
Il2CppString* String::InternalIntern(Il2CppString* str)
|
{
|
return il2cpp_string_intern(str);
|
}
|
|
Il2CppString* String::InternalIsInterned(Il2CppString* str)
|
{
|
return il2cpp_string_is_interned(str);
|
}
|
|
Il2CppString* String::FastAllocateString(int32_t length)
|
{
|
return vm::String::NewSize(length);
|
}
|
} /* namespace System */
|
} /* namespace mscorlib */
|
} /* namespace icalls */
|
} /* namespace il2cpp */
|
