mono/metadata/string-icalls.c

   1 /*
   2  * string-icalls.c: String internal calls for the corlib
   3  *
   4  * Author:
   5  *   Patrik Torstensson (patrik.torstensson@labs2.com)
   6  *   Duncan Mak  (duncan@ximian.com)
   7  *
   8  * (C) 2001 Ximian, Inc.
   9  */
  10 #include <config.h>
  11 #include <stdlib.h>
  12 #include <stdio.h>
  13 #include <signal.h>
  14 #include <string.h>
  15 #include <mono/metadata/string-icalls.h>
  16 #include <mono/metadata/class-internals.h>
  17 #include <mono/metadata/appdomain.h>
  18 #include <mono/metadata/tabledefs.h>
  19 #include <mono/metadata/loader.h>
  20 #include <mono/metadata/object.h>
  21 #include <mono/metadata/unicode.h>
  22 #include <mono/metadata/exception.h>
  23 #include <mono/metadata/debug-helpers.h>
  24
  25 /* Internal helper methods */
  26
  27 static gboolean
  28 string_icall_is_in_array (MonoArray *chars, gint32 arraylength, gunichar2 chr);
  29
  30 MonoString *
  31 ves_icall_System_String_ctor_charp (gpointer dummy, gunichar2 *value)
  32 {
  33         gint32 i, length;
  34         MonoDomain *domain;
  35
  36         MONO_ARCH_SAVE_REGS;
  37
  38         domain = mono_domain_get ();
  39
  40         if (value == NULL)
  41                 length = 0;
  42         else {
  43                 for (i = 0; *(value + i) != '\0'; i++);
  44                 length = i;
  45         }
  46
  47         return mono_string_new_utf16 (domain, value, length);
  48 }
  49
  50 MonoString *
  51 ves_icall_System_String_ctor_char_int (gpointer dummy, gunichar2 value, gint32 count)
  52 {
  53         MonoDomain *domain;
  54         MonoString *res;
  55         gunichar2 *chars;
  56         gint32 i;
  57
  58         MONO_ARCH_SAVE_REGS;
  59
  60         if (count < 0)
  61                 mono_raise_exception (mono_get_exception_argument_out_of_range ("count"));
  62
  63         domain = mono_domain_get ();
  64         res = mono_string_new_size (domain, count);
  65
  66         chars = mono_string_chars (res);
  67         for (i = 0; i < count; i++)
  68                 chars [i] = value;
  69
  70         return res;
  71 }
  72
  73 MonoString *
  74 ves_icall_System_String_ctor_charp_int_int (gpointer dummy, gunichar2 *value, gint32 sindex, gint32 length)
  75 {
  76         gunichar2 *begin;
  77         MonoDomain * domain;
  78
  79         MONO_ARCH_SAVE_REGS;
  80
  81         domain = mono_domain_get ();
  82
  83         if ((value == NULL) && (length != 0))
  84                 mono_raise_exception (mono_get_exception_argument_out_of_range ("Out of range"));
  85
  86         if ((sindex < 0) || (length < 0))
  87                 mono_raise_exception (mono_get_exception_argument_out_of_range ("Out of range"));
  88
  89         if (length == 0) {      /* fixme: return String.Empty here */
  90                 g_warning ("string doesn't yet support empy strings in char* constructor");
  91                 g_assert_not_reached ();
  92         }
  93
  94         begin = (gunichar2 *) (value + sindex);
  95
  96         return mono_string_new_utf16 (domain, begin, length);
  97 }
  98
  99 MonoString *
 100 ves_icall_System_String_ctor_sbytep (gpointer dummy, gint8 *value)
 101 {
 102         MonoDomain *domain;
 103
 104         MONO_ARCH_SAVE_REGS;
 105
 106         domain = mono_domain_get ();
 107
 108         if (NULL == value) {    /* fixme: return String.Empty here */
 109                 g_warning ("string doesn't yet support empy strings in char* constructor");
 110                 g_assert_not_reached ();
 111         }
 112
 113         return mono_string_new (domain, (const char *) value);
 114 }
 115
 116 MonoString *
 117 ves_icall_System_String_ctor_sbytep_int_int (gpointer dummy, gint8 *value, gint32 sindex, gint32 length)
 118 {
 119         guchar *begin;
 120         MonoDomain *domain;
 121         MonoString *res;
 122         gunichar2 *chars;
 123         int i;
 124
 125         MONO_ARCH_SAVE_REGS;
 126
 127         domain = mono_domain_get ();
 128
 129         if ((value == NULL) && (length != 0))
 130                 mono_raise_exception (mono_get_exception_argument_out_of_range ("Out of range"));
 131
 132         if ((sindex < 0) || (length < 0))
 133                 mono_raise_exception (mono_get_exception_argument_out_of_range ("Out of range"));
 134
 135         begin = (guchar *) (value + sindex);
 136         res = mono_string_new_size (domain, length);
 137         chars = mono_string_chars (res);
 138         for (i = 0; i < length; ++i)
 139                 chars [i] = begin [i];
 140
 141         return res;
 142 }
 143
 144 MonoString *
 145 ves_icall_System_String_ctor_chara (gpointer dummy, MonoArray *value)
 146 {
 147         MonoDomain *domain;
 148
 149         MONO_ARCH_SAVE_REGS;
 150
 151         domain = mono_domain_get ();
 152
 153         if (value == NULL)
 154                 return mono_string_new_utf16 (domain, NULL, 0);
 155         else
 156                 return mono_string_new_utf16 (domain, (gunichar2 *) mono_array_addr(value, gunichar2, 0),  value->max_length);
 157 }
 158
 159 MonoString *
 160 ves_icall_System_String_ctor_chara_int_int (gpointer dummy, MonoArray *value,
 161                                          gint32 sindex, gint32 length)
 162 {
 163         MonoDomain *domain;
 164
 165         MONO_ARCH_SAVE_REGS;
 166
 167         if (value == NULL)
 168                 mono_raise_exception (mono_get_exception_argument_null ("value"));
 169         if (sindex < 0)
 170                 mono_raise_exception (mono_get_exception_argument_out_of_range ("startIndex"));
 171         if (length < 0)
 172                 mono_raise_exception (mono_get_exception_argument_out_of_range ("length"));
 173         if (sindex + length > mono_array_length (value))
 174                 mono_raise_exception (mono_get_exception_argument_out_of_range ("Out of range"));
 175
 176         domain = mono_domain_get ();
 177
 178         return mono_string_new_utf16 (domain, (gunichar2 *) mono_array_addr(value, gunichar2, sindex), length);
 179 }
 180
 181 MonoString *
 182 ves_icall_System_String_ctor_encoding (gpointer dummy, gint8 *value, gint32 sindex,
 183                                     gint32 length, MonoObject *enc)
 184 {
 185         MONO_ARCH_SAVE_REGS;
 186         MonoArray *arr;
 187         MonoString *s;
 188         MonoObject *exc;
 189         MonoDomain *domain = mono_domain_get ();
 190         MonoMethod *get_string;
 191         gpointer args [1];
 192
 193         if ((value == NULL) || (length == 0))
 194                 return mono_string_new_size (mono_domain_get (), 0);
 195         if (enc == NULL)
 196                 mono_raise_exception (mono_get_exception_argument_null ("enc"));
 197         if (sindex < 0)
 198                 mono_raise_exception (mono_get_exception_argument_out_of_range ("startIndex"));
 199         if (length < 0)
 200                 mono_raise_exception (mono_get_exception_argument_out_of_range ("length"));
 201
 202         arr = mono_array_new (domain, mono_defaults.byte_class, length);
 203         memcpy (mono_array_addr (arr, guint8*, 0), value + sindex, length);
 204
 205         get_string = mono_find_method_by_name (enc->vtable->klass, "GetString", 1);
 206         args [0] = arr;
 207         s = (MonoString*)mono_runtime_invoke (get_string, enc, args, &exc);
 208         if (!s || exc)
 209                 mono_raise_exception (mono_get_exception_argument ("", "Unable to decode the array into a valid string."));
 210
 211         return s;
 212 }
 213
 214 MonoString *
 215 ves_icall_System_String_InternalJoin (MonoString *separator, MonoArray * value, gint32 sindex, gint32 count)
 216 {
 217         MonoString * ret;
 218         MonoString *current;
 219         gint32 length;
 220         gint32 pos;
 221         gint32 insertlen;
 222         gint32 destpos;
 223         gint32 srclen;
 224         gunichar2 *insert;
 225         gunichar2 *dest;
 226         gunichar2 *src;
 227
 228         MONO_ARCH_SAVE_REGS;
 229
 230         insert = mono_string_chars(separator);
 231         insertlen = mono_string_length(separator);
 232
 233         length = 0;
 234         for (pos = sindex; pos != sindex + count; pos++) {
 235                 current = mono_array_get (value, MonoString *, pos);
 236                 if (current != NULL)
 237                         length += mono_string_length (current);
 238
 239                 if (pos < sindex + count - 1)
 240                         length += insertlen;
 241         }
 242
 243         ret = mono_string_new_size( mono_domain_get (), length);
 244         dest = mono_string_chars(ret);
 245         destpos = 0;
 246
 247         for (pos = sindex; pos != sindex + count; pos++) {
 248                 current = mono_array_get (value, MonoString *, pos);
 249                 if (current != NULL) {
 250                         src = mono_string_chars (current);
 251                         srclen = mono_string_length (current);
 252
 253                         memcpy (dest + destpos, src, srclen * sizeof(gunichar2));
 254                         destpos += srclen;
 255                 }
 256
 257                 if (pos < sindex + count - 1) {
 258                         memcpy(dest + destpos, insert, insertlen * sizeof(gunichar2));
 259                         destpos += insertlen;
 260                 }
 261         }
 262
 263         return ret;
 264 }
 265
 266 MonoString *
 267 ves_icall_System_String_InternalInsert (MonoString *me, gint32 sindex, MonoString *value)
 268 {
 269         MonoString * ret;
 270         gunichar2 *src;
 271         gunichar2 *insertsrc;
 272         gunichar2 *dest;
 273         gint32 srclen;
 274         gint32 insertlen;
 275
 276         MONO_ARCH_SAVE_REGS;
 277
 278         src = mono_string_chars(me);
 279         srclen = mono_string_length(me);
 280
 281         insertsrc = mono_string_chars(value);
 282         insertlen = mono_string_length(value);
 283
 284         ret = mono_string_new_size( mono_domain_get (), srclen + insertlen);
 285         dest = mono_string_chars(ret);
 286
 287         memcpy(dest, src, sindex * sizeof(gunichar2));
 288         memcpy(dest + sindex, insertsrc, insertlen * sizeof(gunichar2));
 289         memcpy(dest + sindex + insertlen, src + sindex, (srclen - sindex) * sizeof(gunichar2));
 290
 291         return ret;
 292 }
 293
 294 MonoString *
 295 ves_icall_System_String_InternalReplace_Char (MonoString *me, gunichar2 oldChar, gunichar2 newChar)
 296 {
 297         MonoString *ret;
 298         gunichar2 *src;
 299         gunichar2 *dest;
 300         gint32 i, srclen;
 301
 302         MONO_ARCH_SAVE_REGS;
 303
 304         src = mono_string_chars(me);
 305         srclen = mono_string_length(me);
 306
 307         ret = mono_string_new_size( mono_domain_get (), srclen);
 308         dest = mono_string_chars(ret);
 309
 310         for (i = 0; i != srclen; i++) {
 311                 if (src[i] == oldChar)
 312                         dest[i] = newChar;
 313                 else
 314                         dest[i] = src[i];
 315         }
 316
 317         return ret;
 318 }
 319
 320 MonoString *
 321 ves_icall_System_String_InternalRemove (MonoString *me, gint32 sindex, gint32 count)
 322 {
 323         MonoString * ret;
 324         gint32 srclen;
 325         gunichar2 *dest;
 326         gunichar2 *src;
 327
 328         MONO_ARCH_SAVE_REGS;
 329
 330         srclen = mono_string_length(me);
 331         ret = mono_string_new_size( mono_domain_get (), srclen - count);
 332
 333         src = mono_string_chars(me);
 334         dest = mono_string_chars(ret);
 335
 336         memcpy(dest, src, sindex * sizeof(gunichar2));
 337         memcpy(dest + sindex, src + sindex + count, (srclen - count - sindex) * sizeof(gunichar2));
 338
 339         return ret;
 340 }
 341
 342 void
 343 ves_icall_System_String_InternalCopyTo (MonoString *me, gint32 sindex, MonoArray *dest, gint32 dindex, gint32 count)
 344 {
 345         gunichar2 *destptr = (gunichar2 *) mono_array_addr(dest, gunichar2, dindex);
 346         gunichar2 *src =  mono_string_chars(me);
 347
 348         MONO_ARCH_SAVE_REGS;
 349
 350         memcpy(destptr, src + sindex, sizeof(gunichar2) * count);
 351 }
 352
 353 MonoArray *
 354 ves_icall_System_String_InternalSplit (MonoString *me, MonoArray *separator, gint32 count)
 355 {
 356         MonoString * tmpstr;
 357         MonoArray * retarr;
 358         gunichar2 *src;
 359         gint32 arrsize, srcsize, splitsize;
 360         gint32 i, lastpos, arrpos;
 361         gint32 tmpstrsize;
 362         gunichar2 *tmpstrptr;
 363
 364         gunichar2 cmpchar;
 365
 366         MONO_ARCH_SAVE_REGS;
 367
 368         src = mono_string_chars(me);
 369         srcsize = mono_string_length(me);
 370         arrsize = mono_array_length(separator);
 371
 372         cmpchar = mono_array_get(separator, gunichar2, 0);
 373
 374         splitsize = 0;
 375         for (i = 0; i != srcsize && splitsize < count; i++) {
 376                 if (string_icall_is_in_array(separator, arrsize, src[i]))
 377                         splitsize++;
 378         }
 379
 380         lastpos = 0;
 381         arrpos = 0;
 382
 383         /* if no split chars found return the string */
 384         if (splitsize == 0) {
 385                 retarr = mono_array_new(mono_domain_get(), mono_get_string_class (), 1);
 386                 mono_array_set(retarr, MonoString *, 0, me);
 387
 388                 return retarr;
 389         }
 390
 391         if (splitsize != count)
 392                 splitsize++;
 393
 394         retarr = mono_array_new(mono_domain_get(), mono_get_string_class (), splitsize);
 395         for (i = 0; i != srcsize && arrpos != count; i++) {
 396                 if (string_icall_is_in_array(separator, arrsize, src[i])) {
 397                         if (arrpos == count - 1)
 398                                 tmpstrsize = srcsize - lastpos;
 399                         else
 400                                 tmpstrsize = i - lastpos;
 401
 402                         tmpstr = mono_string_new_size( mono_domain_get (), tmpstrsize);
 403                         tmpstrptr = mono_string_chars(tmpstr);
 404
 405                         memcpy(tmpstrptr, src + lastpos, tmpstrsize * sizeof(gunichar2));
 406                         mono_array_set(retarr, MonoString *, arrpos, tmpstr);
 407                         arrpos++;
 408                         lastpos = i + 1;
 409                 }
 410         }
 411
 412         if (arrpos < count) {
 413                 tmpstrsize = srcsize - lastpos;
 414                 tmpstr = mono_string_new_size( mono_domain_get (), tmpstrsize);
 415                 tmpstrptr = mono_string_chars(tmpstr);
 416
 417                 memcpy(tmpstrptr, src + lastpos, tmpstrsize * sizeof(gunichar2));
 418                 mono_array_set(retarr, MonoString *, arrpos, tmpstr);
 419         }
 420
 421         return retarr;
 422 }
 423
 424 static gboolean
 425 string_icall_is_in_array (MonoArray *chars, gint32 arraylength, gunichar2 chr)
 426 {
 427         gunichar2 cmpchar;
 428         gint32 arrpos;
 429
 430         for (arrpos = 0; arrpos != arraylength; arrpos++) {
 431                 cmpchar = mono_array_get(chars, gunichar2, arrpos);
 432                 if (cmpchar == chr)
 433                         return TRUE;
 434         }
 435
 436         return FALSE;
 437 }
 438
 439 MonoString *
 440 ves_icall_System_String_InternalTrim (MonoString *me, MonoArray *chars, gint32 typ)
 441 {
 442         MonoString * ret;
 443         gunichar2 *src, *dest;
 444         gint32 srclen, newlen, arrlen;
 445         gint32 i, lenfirst, lenlast;
 446
 447         MONO_ARCH_SAVE_REGS;
 448
 449         srclen = mono_string_length(me);
 450         src = mono_string_chars(me);
 451         arrlen = mono_array_length(chars);
 452
 453         lenfirst = 0;
 454         lenlast = 0;
 455
 456         if (0 == typ || 1 == typ) {
 457                 for (i = 0; i != srclen; i++) {
 458                         if (string_icall_is_in_array(chars, arrlen, src[i]))
 459                                 lenfirst++;
 460                         else
 461                                 break;
 462                 }
 463         }
 464
 465         if (0 == typ || 2 == typ) {
 466                 for (i = srclen - 1; i > lenfirst - 1; i--) {
 467                         if (string_icall_is_in_array(chars, arrlen, src[i]))
 468                                 lenlast++;
 469                         else
 470                                 break;
 471                 }
 472         }
 473
 474         newlen = srclen - lenfirst - lenlast;
 475         if (newlen == srclen)
 476                 return me;
 477
 478         ret = mono_string_new_size( mono_domain_get (), newlen);
 479         dest = mono_string_chars(ret);
 480
 481         memcpy(dest, src + lenfirst, newlen *sizeof(gunichar2));
 482
 483         return ret;
 484 }
 485
 486 gint32
 487 ves_icall_System_String_InternalIndexOfAny (MonoString *me, MonoArray *arr, gint32 sindex, gint32 count)
 488 {
 489         gint32 pos;
 490         gint32 loop;
 491         gint32 arraysize;
 492         gunichar2 *src;
 493
 494         MONO_ARCH_SAVE_REGS;
 495
 496         arraysize = mono_array_length(arr);
 497         src = mono_string_chars(me);
 498
 499         for (pos = sindex; pos != count + sindex; pos++) {
 500                 for (loop = 0; loop != arraysize; loop++)
 501                         if ( src [pos] == mono_array_get(arr, gunichar2, loop) )
 502                                 return pos;
 503         }
 504
 505         return -1;
 506 }
 507
 508 gint32
 509 ves_icall_System_String_InternalLastIndexOf_Char (MonoString *me, gunichar2 value, gint32 sindex, gint32 count)
 510 {
 511         gint32 pos;
 512         gunichar2 *src;
 513
 514         MONO_ARCH_SAVE_REGS;
 515
 516         src = mono_string_chars(me);
 517         for (pos = sindex; pos > sindex - count; pos--) {
 518                 if (src [pos] == value)
 519                         return pos;
 520         }
 521
 522         return -1;
 523 }
 524
 525 gint32
 526 ves_icall_System_String_InternalLastIndexOf_Str (MonoString *me, MonoString *value, gint32 sindex, gint32 count)
 527 {
 528         gint32 lencmpstr;
 529         gint32 pos;
 530         gunichar2 *src;
 531         gunichar2 *cmpstr;
 532
 533         MONO_ARCH_SAVE_REGS;
 534
 535         lencmpstr = mono_string_length(value);
 536
 537         src = mono_string_chars(me);
 538         cmpstr = mono_string_chars(value);
 539
 540         for (pos = sindex - lencmpstr + 1; pos > sindex - count; pos--) {
 541                 if (0 == memcmp(src + pos, cmpstr, lencmpstr * sizeof(gunichar2)))
 542                         return pos;
 543         }
 544
 545         return -1;
 546 }
 547
 548 gint32
 549 ves_icall_System_String_InternalLastIndexOfAny (MonoString *me, MonoArray *anyOf, gint32 sindex, gint32 count)
 550 {
 551         gint32 pos;
 552         gint32 loop;
 553         gint32 arraysize;
 554         gunichar2 *src;
 555
 556         MONO_ARCH_SAVE_REGS;
 557
 558         arraysize = mono_array_length(anyOf);
 559         src = mono_string_chars(me);
 560
 561         for (pos = sindex; pos > sindex - count; pos--) {
 562                 for (loop = 0; loop != arraysize; loop++)
 563                         if ( src [pos] == mono_array_get(anyOf, gunichar2, loop) )
 564                                 return pos;
 565         }
 566
 567         return -1;
 568 }
 569
 570 MonoString *
 571 ves_icall_System_String_InternalPad (MonoString *me, gint32 width, gunichar2 chr, MonoBoolean right)
 572 {
 573         MonoString * ret;
 574         gunichar2 *src;
 575         gunichar2 *dest;
 576         gint32 fillcount;
 577         gint32 srclen;
 578         gint32 i;
 579
 580         MONO_ARCH_SAVE_REGS;
 581
 582         srclen = mono_string_length(me);
 583         src = mono_string_chars(me);
 584
 585         ret = mono_string_new_size( mono_domain_get (), width);
 586         dest = mono_string_chars(ret);
 587         fillcount = width - srclen;
 588
 589         if (right) {
 590                 memcpy(dest, src, srclen * sizeof(gunichar2));
 591                 for (i = srclen; i != width; i++)
 592                         dest[i] = chr;
 593
 594                 return ret;
 595         }
 596
 597         /* left fill */
 598         for (i = 0; i != fillcount; i++)
 599                 dest[i] = chr;
 600
 601         memcpy(dest + fillcount, src, srclen * sizeof(gunichar2));
 602
 603         return ret;
 604 }
 605
 606 MonoString *
 607 ves_icall_System_String_InternalAllocateStr (gint32 length)
 608 {
 609         MONO_ARCH_SAVE_REGS;
 610
 611         return mono_string_new_size(mono_domain_get (), length);
 612 }
 613
 614 void
 615 ves_icall_System_String_InternalStrcpy_Str (MonoString *dest, gint32 destPos, MonoString *src)
 616 {
 617         gunichar2 *srcptr;
 618         gunichar2 *destptr;
 619
 620         MONO_ARCH_SAVE_REGS;
 621
 622         srcptr = mono_string_chars (src);
 623         destptr = mono_string_chars (dest);
 624
 625         g_memmove (destptr + destPos, srcptr, mono_string_length(src) * sizeof(gunichar2));
 626 }
 627
 628 void
 629 ves_icall_System_String_InternalStrcpy_StrN (MonoString *dest, gint32 destPos, MonoString *src, gint32 startPos, gint32 count)
 630 {
 631         gunichar2 *srcptr;
 632         gunichar2 *destptr;
 633
 634         MONO_ARCH_SAVE_REGS;
 635
 636         srcptr = mono_string_chars (src);
 637         destptr = mono_string_chars (dest);
 638         g_memmove (destptr + destPos, srcptr + startPos, count * sizeof(gunichar2));
 639 }
 640
 641 void
 642 ves_icall_System_String_InternalStrcpy_Chars (MonoString *dest, gint32 destPos, MonoArray *src)
 643 {
 644         gunichar2 *srcptr;
 645         gunichar2 *destptr;
 646
 647         MONO_ARCH_SAVE_REGS;
 648
 649         srcptr = mono_array_addr (src, gunichar2, 0);
 650         destptr = mono_string_chars (dest);
 651
 652         g_memmove (destptr + destPos, srcptr, mono_array_length (src) * sizeof(gunichar2));
 653 }
 654
 655 void
 656 ves_icall_System_String_InternalStrcpy_CharsN (MonoString *dest, gint32 destPos, MonoArray *src, gint32 startPos, gint32 count)
 657 {
 658         gunichar2 *srcptr;
 659         gunichar2 *destptr;
 660
 661         MONO_ARCH_SAVE_REGS;
 662
 663         srcptr = mono_array_addr (src, gunichar2, 0);
 664         destptr = mono_string_chars (dest);
 665
 666         g_memmove (destptr + destPos, srcptr + startPos, count * sizeof(gunichar2));
 667 }
 668
 669 MonoString  *
 670 ves_icall_System_String_InternalIntern (MonoString *str)
 671 {
 672         MONO_ARCH_SAVE_REGS;
 673
 674         return mono_string_intern(str);
 675 }
 676
 677 MonoString *
 678 ves_icall_System_String_InternalIsInterned (MonoString *str)
 679 {
 680         MONO_ARCH_SAVE_REGS;
 681
 682         return mono_string_is_interned(str);
 683 }
 684
 685 gint32
 686 ves_icall_System_String_GetHashCode (MonoString *me)
 687 {
 688         int i, h = 0;
 689         gunichar2 *data = mono_string_chars (me);
 690
 691         MONO_ARCH_SAVE_REGS;
 692
 693         for (i = 0; i < mono_string_length (me); ++i)
 694                 h = (h << 5) - h + data [i];
 695
 696         return h;
 697 }
 698
 699 gunichar2
 700 ves_icall_System_String_get_Chars (MonoString *me, gint32 idx)
 701 {
 702         MONO_ARCH_SAVE_REGS;
 703
 704         if ((idx < 0) || (idx >= mono_string_length (me)))
 705                 mono_raise_exception (mono_get_exception_index_out_of_range ());
 706         return mono_string_chars(me)[idx];
 707 }
 708
 709 void
 710 ves_icall_System_String_InternalCharCopy (gunichar2 *src, gunichar2 *dest, gint32 count)
 711 {
 712         MONO_ARCH_SAVE_REGS;
 713
 714         memcpy (dest, src, sizeof (gunichar2) * count);
 715 }