char *monostring_to_string(MonoString *string_obj)
{
mono_unichar2 *uni_buffer = mono_string_chars(string_obj);
int len = mono_string_length(string_obj);
char *buffer = new char[len + 1];
for (int i = 0; i < len; i++) {
buffer[i] = get_char_from_unicode(uni_buffer[i]);
}
buffer[len] = '\0';
return buffer;
}
void ves_icall_System_Globalization_CompareInfo_assign_sortkey (MonoCompareInfo *this_obj, MonoSortKey *key, MonoString *source, gint32 options)
{
MonoArray *arr;
gint32 keylen, i;
keylen=mono_string_length (source);
arr=mono_array_new (mono_domain_get (), mono_get_byte_class (),
keylen);
for(i=0; i<keylen; i++) {
mono_array_set (arr, guint8, i, mono_string_chars (source)[i]);
}
MONO_OBJECT_SETREF (key, key, arr);
}
String mono_to_utf16_string(MonoString *p_mono_string) {
int len = mono_string_length(p_mono_string);
String ret;
if (len == 0)
return ret;
ret.resize(len + 1);
ret.set(len, 0);
CharType *src = (CharType *)mono_string_chars(p_mono_string);
CharType *dst = &(ret.operator[](0));
for (int i = 0; i < len; i++) {
dst[i] = src[i];
}
return ret;
}
static gboolean saved_strings_find_func (gpointer key, gpointer value, gpointer user_data)
{
SavedStringFindInfo *info = (SavedStringFindInfo*)user_data;
SavedString *saved = (SavedString*)value;
gchar *utf_str;
guint32 hash;
if (!info || !saved || mono_string_length (saved->string) != info->len)
return FALSE;
utf_str = mono_string_to_utf8 (saved->string);
hash = do_calc_string_hash (0, utf_str);
g_free (utf_str);
if (hash != info->hash)
return FALSE;
return TRUE;
}
static gint32 string_invariant_indexof (MonoString *source, gint32 sindex,
gint32 count, MonoString *value,
MonoBoolean first)
{
gint32 lencmpstr;
gunichar2 *src;
gunichar2 *cmpstr;
gint32 pos,i;
lencmpstr = mono_string_length(value);
src = mono_string_chars(source);
cmpstr = mono_string_chars(value);
if(first) {
count -= lencmpstr;
for(pos=sindex;pos <= sindex+count;pos++) {
for(i=0;src[pos+i]==cmpstr[i];) {
if(++i==lencmpstr) {
return(pos);
}
}
}
return(-1);
} else {
for(pos=sindex-lencmpstr+1;pos>sindex-count;pos--) {
if(memcmp (src+pos, cmpstr,
lencmpstr*sizeof(gunichar2))==0) {
return(pos);
}
}
return(-1);
}
}
MonoArray *
ves_icall_System_String_InternalSplit (MonoString *me, MonoArray *separator, gint32 count, gint32 options)
{
static MonoClass *String_array;
MonoString * tmpstr;
MonoArray * retarr;
gunichar2 *src;
gint32 arrsize, srcsize, splitsize;
gint32 i, lastpos, arrpos;
gint32 tmpstrsize;
gint32 remempty;
gint32 flag;
gunichar2 *tmpstrptr;
remempty = options & STRINGSPLITOPTIONS_REMOVE_EMPTY_ENTRIES;
src = mono_string_chars (me);
srcsize = mono_string_length (me);
arrsize = mono_array_length (separator);
if (!String_array) {
MonoClass *klass = mono_array_class_get (mono_get_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 = mono_array_new_specific (mono_class_vtable (mono_domain_get (), 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 = mono_array_new_specific (mono_class_vtable (mono_domain_get (), String_array), 1);
mono_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 = mono_string_new_size (mono_domain_get (), srcsize);
tmpstrptr = mono_string_chars (tmpstr);
memcpy (tmpstrptr, src, srcsize * sizeof (gunichar2));
retarr = mono_array_new_specific (mono_class_vtable (mono_domain_get (), String_array), 1);
mono_array_setref (retarr, 0, tmpstr);
}
return retarr;
}
lastpos = 0;
arrpos = 0;
retarr = mono_array_new_specific (mono_class_vtable (mono_domain_get (), 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 = mono_string_new_size (mono_domain_get (), tmpstrsize);
tmpstrptr = mono_string_chars (tmpstr);
memcpy (tmpstrptr, src + lastpos, tmpstrsize * sizeof (gunichar2));
mono_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 = mono_string_new_size (mono_domain_get (), tmpstrsize);
tmpstrptr = mono_string_chars (tmpstr);
memcpy (tmpstrptr, src + lastpos, tmpstrsize * sizeof (gunichar2));
mono_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;
}
static MonoString *string_invariant_replace (MonoString *me,
MonoString *oldValue,
MonoString *newValue)
{
MonoString *ret;
gunichar2 *src;
gunichar2 *dest=NULL; /* shut gcc up */
gunichar2 *oldstr;
gunichar2 *newstr=NULL; /* shut gcc up here too */
gint32 i, destpos;
gint32 occurr;
gint32 newsize;
gint32 oldstrlen;
gint32 newstrlen;
gint32 srclen;
occurr = 0;
destpos = 0;
oldstr = mono_string_chars(oldValue);
oldstrlen = mono_string_length(oldValue);
if (NULL != newValue) {
newstr = mono_string_chars(newValue);
newstrlen = mono_string_length(newValue);
} else
newstrlen = 0;
src = mono_string_chars(me);
srclen = mono_string_length(me);
if (oldstrlen != newstrlen) {
i = 0;
while (i <= srclen - oldstrlen) {
if (0 == memcmp(src + i, oldstr, oldstrlen * sizeof(gunichar2))) {
occurr++;
i += oldstrlen;
}
else
i ++;
}
if (occurr == 0)
return me;
newsize = srclen + ((newstrlen - oldstrlen) * occurr);
} else
newsize = srclen;
ret = NULL;
i = 0;
while (i < srclen) {
if (0 == memcmp(src + i, oldstr, oldstrlen * sizeof(gunichar2))) {
if (ret == NULL) {
ret = mono_string_new_size( mono_domain_get (), newsize);
dest = mono_string_chars(ret);
memcpy (dest, src, i * sizeof(gunichar2));
}
if (newstrlen > 0) {
memcpy(dest + destpos, newstr, newstrlen * sizeof(gunichar2));
destpos += newstrlen;
}
i += oldstrlen;
continue;
} else if (ret != NULL) {
dest[destpos] = src[i];
}
destpos++;
i++;
}
if (ret == NULL)
return me;
return ret;
}
