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  *
   7  * (C) 2001 Ximian, Inc.
   8  */
   9 #include <config.h>
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include <signal.h>
  13 #include <string.h>
  14 #include <mono/metadata/string-icalls.h>
  15 #include <mono/metadata/appdomain.h>
  16 #include <mono/metadata/tabledefs.h>
  17 #include <mono/metadata/loader.h>
  18 #include <mono/metadata/object.h>
  19 #include <mono/metadata/unicode.h>
  20
  21 MonoString *
  22 mono_string_InternalJoin (MonoString *separator, MonoArray * value, gint32 sindex, gint32 count)
  23 {
  24         MonoString * ret;
  25         gint32 length;
  26         gint32 pos;
  27         gint32 insertlen;
  28         gint32 destpos;
  29         gint32 srclen;
  30         gunichar2 *insert;
  31         gunichar2 *dest;
  32         gunichar2 *src;
  33
  34         insert = mono_string_chars(separator);
  35         insertlen = mono_string_length(separator);
  36
  37         length = 0;
  38         for (pos = sindex; pos != sindex + count; pos++) {
  39                 length += mono_string_length(mono_array_get(value, MonoString *, pos));
  40                 if (pos < sindex + count - 1)
  41                         length += insertlen;
  42         }
  43
  44         ret = mono_string_InternalAllocateStr(length);
  45         dest = mono_string_chars(ret);
  46         destpos = 0;
  47
  48         for (pos = sindex; pos != sindex + count; pos++) {
  49                 src = mono_string_chars(mono_array_get(value, MonoString *, pos));
  50                 srclen = mono_string_length(mono_array_get(value, MonoString *, pos));
  51
  52                 memcpy(dest + destpos, src, srclen * sizeof(gunichar2));
  53                 destpos += srclen;
  54
  55                 if (pos < sindex + count - 1) {
  56                         memcpy(dest + destpos, insert, insertlen * sizeof(gunichar2));
  57                         destpos += insertlen;
  58                 }
  59         }
  60
  61         return ret;
  62 }
  63
  64 MonoString *
  65 mono_string_InternalInsert (MonoString *me, gint32 sindex, MonoString *value)
  66 {
  67         MonoString * ret;
  68         gunichar2 *src;
  69         gunichar2 *insertsrc;
  70         gunichar2 *dest;
  71         gint32 srclen;
  72
  73         src = mono_string_chars(me);
  74         srclen = mono_string_length(value);
  75
  76         ret = mono_string_InternalAllocateStr(mono_string_length(me) + srclen - sindex);
  77         dest = mono_string_chars(ret);
  78
  79         memcpy(dest, src, sindex * sizeof(gunichar2));
  80         memcpy(dest + sindex, insertsrc, srclen * sizeof(gunichar2));
  81
  82         return ret;
  83 }
  84
  85 MonoString *
  86 mono_string_InternalReplaceChar (MonoString *me, gunichar2 oldChar, gunichar2 newChar)
  87 {
  88         g_warning("mono_string_InternalReplaceChar not impl");
  89         return mono_string_new_utf16(mono_domain_get(), mono_string_chars(me), mono_string_length(me));
  90 }
  91
  92 MonoString *
  93 mono_string_InternalReplaceStr (MonoString *me, MonoString *oldValue, MonoString *newValue)
  94 {
  95         g_warning("mono_string_InternalReplaceStr not impl");
  96         return mono_string_new_utf16(mono_domain_get(), mono_string_chars(me), mono_string_length(me));
  97 }
  98
  99 MonoString *
 100 mono_string_InternalRemove (MonoString *me, gint32 sindex, gint32 count)
 101 {
 102         MonoString * ret;
 103         gint32 count_bytes;
 104         gint32 index_bytes;
 105         gunichar2 *dest;
 106         gunichar2 *src;
 107
 108         ret = mono_string_InternalAllocateStr(mono_string_length(me) - count);
 109         index_bytes = sindex * sizeof(gunichar2);
 110         count_bytes = count * sizeof(gunichar2);
 111
 112         src = mono_string_chars(me);
 113         dest = mono_string_chars(ret);
 114
 115         memcpy(dest, src, index_bytes);
 116         memcpy(dest + sindex, src + sindex + count, index_bytes - count_bytes);
 117
 118         return ret;
 119 }
 120
 121 void
 122 mono_string_InternalCopyTo (MonoString *me, gint32 sindex, MonoArray *dest, gint32 dindex, gint32 count)
 123 {
 124         gunichar2 *destptr = (gunichar2 *) mono_array_addr(dest, gunichar2, dindex);
 125         gunichar2 *src =  mono_string_chars(me);
 126
 127         memcpy(destptr, src + sindex, sizeof(gunichar2) * count);
 128 }
 129
 130 MonoArray *
 131 mono_string_InternalSplit (MonoString *me, MonoArray *separator, gint32 count)
 132 {
 133         MonoString * tmpstr;
 134         MonoArray * retarr;
 135         gunichar2 *src;
 136         gint32 arrsize, srcsize, splitsize;
 137         gint32 i, lastpos, arrpos;
 138         gint32 tmpstrsize;
 139         gunichar2 *tmpstrptr;
 140
 141         src = mono_string_chars(me);
 142         srcsize = mono_string_length(me);
 143         arrsize = mono_array_length(separator);
 144
 145         splitsize = 0;
 146         for (i = 0; i != srcsize && splitsize < count; i++) {
 147                 if (mono_string_isinarray(separator, arrsize, src[i]))
 148                         splitsize++;
 149         }
 150
 151         lastpos = 0;
 152         arrpos = 0;
 153
 154         // if no split chars found return the string
 155         if (splitsize == 0) {
 156                 retarr = mono_array_new(mono_domain_get(), mono_defaults.string_class, 1);
 157                 tmpstr = mono_string_InternalAllocateStr(srcsize);
 158                 tmpstrptr = mono_string_chars(tmpstr);
 159
 160                 memcpy(tmpstrptr, src, srcsize * sizeof(gunichar2));
 161                 mono_array_set(retarr, MonoString *, 0, tmpstr);
 162
 163                 return retarr;
 164         }
 165
 166         retarr = mono_array_new(mono_domain_get(), mono_defaults.string_class, splitsize);
 167         for (i = 0; i != srcsize && arrpos != count; i++) {
 168                 if (mono_string_isinarray(separator, arrsize, src[i])) {
 169                         if (arrpos == count - 1)
 170                                 tmpstrsize = srcsize - lastpos;
 171                         else
 172                                 tmpstrsize = i - lastpos;
 173
 174                         tmpstr = mono_string_InternalAllocateStr(tmpstrsize);
 175                         tmpstrptr = mono_string_chars(tmpstr);
 176
 177                         memcpy(tmpstrptr, src + lastpos, tmpstrsize * sizeof(gunichar2));
 178                         mono_array_set(retarr, MonoString *, arrpos, tmpstr);
 179                         arrpos++;
 180                         lastpos = i + 1;
 181                 }
 182         }
 183
 184         return retarr;
 185 }
 186
 187 gboolean
 188 mono_string_isinarray (MonoArray *chars, gint32 arraylength, gunichar2 chr)
 189 {
 190         gunichar2 cmpchar;
 191         gint32 arrpos;
 192
 193         for (arrpos = 0; arrpos != arraylength; arrpos++) {
 194                 cmpchar = mono_array_get(chars, gunichar2, arrpos);
 195                 if (mono_string_cmp_char(cmpchar, chr, 1) == 0)
 196                         return TRUE;
 197         }
 198
 199         return FALSE;
 200 }
 201
 202 MonoString *
 203 mono_string_InternalTrim (MonoString *me, MonoArray *chars, gint32 typ)
 204 {
 205         MonoString * ret;
 206         gunichar2 *src, *dest;
 207         gint32 srclen, newlen, arrlen;
 208         gint32 i, lenfirst, lenlast;
 209
 210         srclen = mono_string_length(me);
 211         src = mono_string_chars(me);
 212         arrlen = mono_array_length(chars);
 213
 214         lenfirst = 0;
 215         lenlast = 0;
 216
 217         if (0 == typ || 1 == typ) {
 218                 for (i = 0; i != srclen; i++) {
 219                         if (mono_string_isinarray(chars, arrlen, src[i]))
 220                                 lenfirst++;
 221                         else
 222                                 break;
 223                 }
 224         }
 225
 226         if (0 == typ || 2 == typ) {
 227                 for (i = srclen - lenfirst; i != 0; i--) {
 228                         if (mono_string_isinarray(chars, arrlen, src[i]))
 229                                 lenlast++;
 230                         else
 231                                 break;
 232                 }
 233         }
 234
 235         newlen = srclen - lenfirst - lenlast;
 236
 237         ret = mono_string_InternalAllocateStr(newlen);
 238         dest = mono_string_chars(ret);
 239
 240         memcpy(dest, src + lenfirst, newlen *sizeof(gunichar2));
 241
 242         return ret;
 243 }
 244
 245 gint32
 246 mono_string_InternalIndexOfChar (MonoString *me, gunichar2 value, gint32 sindex, gint32 count)
 247 {
 248         gint32 pos;
 249         gunichar2 *src;
 250
 251         src = mono_string_chars(me);
 252         for (pos = sindex; pos != count + sindex; pos++) {
 253                 if (mono_string_cmp_char(src[pos], value ,1) == 0)
 254                         return pos;
 255         }
 256
 257         return -1;
 258 }
 259
 260 gint32
 261 mono_string_InternalIndexOfStr (MonoString *me, MonoString *value, gint32 sindex, gint32 count)
 262 {
 263         gint32 lencmpstr;
 264         gint32 pos;
 265         gunichar2 *src;
 266         gunichar2 *cmpstr;
 267
 268         lencmpstr = mono_string_length(value);
 269
 270         src = mono_string_chars(me);
 271         cmpstr = mono_string_chars(value);
 272
 273         for (pos = sindex; pos != count + sindex; pos++) {
 274                 if (0 == mono_string_InternalCompareStrN(me, pos, value, 0, lencmpstr, 0)) {
 275                         return pos;
 276                 }
 277         }
 278
 279         return -1;
 280 }
 281
 282 gint32
 283 mono_string_InternalIndexOfAny (MonoString *me, MonoArray *arr, gint32 sindex, gint32 count)
 284 {
 285         gint32 pos;
 286         gint32 arraysize;
 287         gunichar2 *src;
 288
 289         arraysize = mono_array_length(arr);
 290         src = mono_string_chars(me);
 291
 292         for (pos = sindex; pos != count + sindex; pos++) {
 293                 if (mono_string_isinarray(arr, arraysize, src[pos]))
 294                         return pos;
 295         }
 296
 297         return -1;
 298 }
 299
 300 gint32
 301 mono_string_InternalLastIndexOfChar (MonoString *me, gunichar2 value, gint32 sindex, gint32 count)
 302 {
 303         gint32 pos;
 304         gunichar2 *src;
 305
 306         src = mono_string_chars(me);
 307         for (pos = sindex; pos > sindex - count; pos--) {
 308                 if (mono_string_cmp_char(src[pos], value ,1) == 0)
 309                         return pos;
 310         }
 311
 312         return -1;
 313 }
 314
 315 gint32
 316 mono_string_InternalLastIndexOfStr (MonoString *me, MonoString *value, gint32 sindex, gint32 count)
 317 {
 318         gint32 lencmpstr;
 319         gint32 pos;
 320         gunichar2 *src;
 321         gunichar2 *cmpstr;
 322
 323         lencmpstr = mono_string_length(value);
 324
 325         src = mono_string_chars(me);
 326         cmpstr = mono_string_chars(value);
 327
 328         for (pos = sindex; pos > sindex - count; pos -= lencmpstr) {
 329                 if (0 == mono_string_InternalCompareStrN(me, pos, value, 0, lencmpstr, 0)) {
 330                         return pos;
 331                 }
 332         }
 333
 334         return -1;
 335 }
 336
 337 gint32
 338 mono_string_InternalLastIndexOfAny (MonoString *me, MonoArray *anyOf, gint32 sindex, gint32 count)
 339 {
 340         gint32 pos;
 341         gint32 arraysize;
 342         gunichar2 *src;
 343
 344         arraysize = mono_array_length(anyOf);
 345         src = mono_string_chars(me);
 346
 347         for (pos = sindex; pos > sindex - count; pos--) {
 348                 if (mono_string_isinarray(anyOf, arraysize, src[pos]))
 349                         return pos;
 350         }
 351
 352         return -1;
 353 }
 354
 355 MonoString *
 356 mono_string_InternalPad (MonoString *me, gint32 width, gint16 chr, MonoBoolean right)
 357 {
 358         MonoString * ret;
 359         gunichar2 *src;
 360         gunichar2 *dest;
 361         gint32 fillcount;
 362         gint32 srclen;
 363         gint32 i;
 364
 365         srclen = mono_string_length(me);
 366         src = mono_string_chars(me);
 367
 368         ret = mono_string_InternalAllocateStr(width);
 369         dest = mono_string_chars(ret);
 370         fillcount = width - srclen;
 371
 372         if (right) {
 373                 memcpy(dest, src, srclen * sizeof(gunichar2));
 374                 for (i = srclen; i != width; i++)
 375                         dest[i] = chr;
 376
 377                 return ret;
 378         }
 379
 380         // left fill
 381         for (i = 0; i != fillcount; i++)
 382                 dest[i] = chr;
 383
 384         memcpy(dest + fillcount, src, srclen * sizeof(gunichar2));
 385
 386         return ret;
 387 }
 388
 389 MonoString *
 390 mono_string_InternalToLower (MonoString *me)
 391 {
 392         MonoString * ret;
 393         gunichar2 *src;
 394         gunichar2 *dest;
 395         gint32 i;
 396
 397         ret = mono_string_new_size(mono_domain_get (), mono_string_length(me));
 398
 399         src = mono_string_chars (me);
 400         dest = mono_string_chars (ret);
 401
 402         for (i = 0; i < mono_string_length (me); ++i)
 403                 dest[i] = g_unichar_tolower(src[i]);
 404
 405         return ret;
 406 }
 407
 408 MonoString *
 409 mono_string_InternalToUpper (MonoString *me)
 410 {
 411         int i;
 412         MonoString * ret;
 413         gunichar2 *src;
 414         gunichar2 *dest;
 415
 416         ret = mono_string_new_size(mono_domain_get (), mono_string_length(me));
 417
 418         src = mono_string_chars (me);
 419         dest = mono_string_chars (ret);
 420
 421         for (i = 0; i < mono_string_length (me); ++i)
 422                 dest[i] = g_unichar_toupper(src[i]);
 423
 424         return ret;
 425 }
 426
 427 MonoString *
 428 mono_string_InternalAllocateStr(gint32 length)
 429 {
 430         return mono_string_new_size(mono_domain_get (), length);
 431 }
 432
 433 void
 434 mono_string_InternalStrcpyStr (MonoString *dest, gint32 destPos, MonoString *src)
 435 {
 436         gunichar2 *srcptr;
 437         gunichar2 *destptr;
 438
 439         srcptr = mono_string_chars(src);
 440         destptr = mono_string_chars(dest);
 441
 442         memcpy(destptr + destPos, srcptr, mono_string_length(src) * sizeof(gunichar2));
 443 }
 444
 445 void
 446 mono_string_InternalStrcpyStrN (MonoString *dest, gint32 destPos, MonoString *src, gint32 startPos, gint32 count)
 447 {
 448         gunichar2 *srcptr;
 449         gunichar2 *destptr;
 450
 451         srcptr = mono_string_chars(src);
 452         destptr = mono_string_chars(dest);
 453         memcpy(destptr + destPos, srcptr + startPos, count * sizeof(gunichar2));
 454 }
 455
 456 MonoString  *
 457 mono_string_InternalIntern (MonoString *str)
 458 {
 459         return mono_string_intern(str);
 460 }
 461
 462 MonoString *
 463 mono_string_InternalIsInterned (MonoString *str)
 464 {
 465         return mono_string_is_interned(str);
 466 }
 467
 468 gint32
 469 mono_string_InternalCompareStrN (MonoString *s1, gint32 i1, MonoString *s2, gint32 i2, gint32 length, MonoBoolean inCase)
 470 {
 471         // c translation of C# code.. :)
 472         //
 473         gint32 lenstr1;
 474         gint32 lenstr2;
 475         gunichar2 *str1;
 476         gunichar2 *str2;
 477
 478         gint32 pos;
 479         gint16 mode;
 480
 481         if (inCase)
 482                 mode = 1;
 483         else
 484                 mode = 0;
 485
 486         lenstr1 = mono_string_length(s1);
 487         lenstr2 = mono_string_length(s2);
 488
 489         str1 = mono_string_chars(s1);
 490         str2 = mono_string_chars(s2);
 491
 492         pos = 0;
 493
 494         for (pos = 0; pos != length; pos++) {
 495                 if (i1 + pos >= lenstr1 || i2 + pos >= lenstr2)
 496                         break;
 497
 498                 if (0 != mono_string_cmp_char(str1[i1 + pos], str2[i2 + pos], mode))
 499                         break;
 500         }
 501
 502         // the lesser wins, so if we have looped until length we just need to check the last char
 503         if (pos == length) {
 504                 return mono_string_cmp_char(str1[i1 + pos - 1], str2[i2 + pos - 1], mode);
 505         }
 506
 507         // Test if one the strings has been compared to the end
 508         if (i1 + pos >= lenstr1) {
 509                 if (i2 + pos >= lenstr2)
 510                         return 0;
 511                 else
 512                         return -1;
 513         } else if (i2 + pos >= lenstr2)
 514                 return 1;
 515
 516         // if not, check our last char only.. (can this happen?)
 517         return mono_string_cmp_char(str1[i1 + pos], str2[i2 + pos], mode);
 518 }
 519
 520 gint32
 521 mono_string_GetHashCode (MonoString *me)
 522 {
 523         int i, h = 0;
 524         gunichar2 *data = mono_string_chars (me);
 525
 526         for (i = 0; i < mono_string_length (me); ++i)
 527                 h = (h << 5) - h + data [i];
 528
 529         return h;
 530 }
 531
 532 gunichar2
 533 mono_string_get_Chars (MonoString *me, gint32 idx)
 534 {
 535         return mono_string_chars(me)[idx];
 536 }
 537
 538 /* @mode :      0 = StringCompareModeDirect
 539                         1 = StringCompareModeCaseInsensitive
 540                         2 = StringCompareModeOrdinal
 541 */
 542 gint32
 543 mono_string_cmp_char (gunichar2 c1, gunichar2 c2, gint16 mode)
 544 {
 545         gint32 result;
 546
 547         switch (mode) {
 548         case 0:
 549                 // TODO: compare with culture info
 550                 if (g_unichar_isupper(c1) && g_unichar_islower(c2))
 551                         return 1;
 552
 553                 if (g_unichar_islower(c1) && g_unichar_isupper(c2))
 554                         return -1;
 555
 556                 result = (gint32) c1 - c2;
 557                 break;
 558         case 1:
 559                 result = (gint32) g_unichar_tolower(c1) - g_unichar_tolower(c2);
 560                 break;
 561         // fix: compare ordinal
 562         case 2:
 563                 result = (gint32) g_unichar_tolower(c1) - g_unichar_tolower(c2);
 564                 break;
 565         }
 566
 567         if (result < 0)
 568                 return -1;
 569
 570         if (result > 0)
 571                 return 1;
 572
 573         return 0;
 574 }