netcore/System.Private.CoreLib/src/System/String.Mono.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Runtime.CompilerServices;
   6 using Internal.Runtime.CompilerServices;
   7
   8 namespace System
   9 {
  10         partial class String
  11         {
  12                 [Intrinsic]
  13                 public static readonly String Empty;
  14
  15                 public int Length {
  16                         [Intrinsic]
  17                         get => _stringLength;
  18                 }
  19
  20                 [IndexerName ("Chars")]
  21                 public char this [int index] {
  22                         [Intrinsic]
  23                         get => this [index];
  24                 }
  25
  26                 public static String Intern (String str)
  27                 {
  28                         if (str == null)
  29                                 throw new ArgumentNullException(nameof(str));
  30
  31                         return InternalIntern (str);
  32                 }
  33
  34                 public static String IsInterned (String str)
  35                 {
  36                         if (str == null)
  37                                 throw new ArgumentNullException(nameof(str));
  38
  39                         return InternalIsInterned (str);
  40                 }
  41
  42                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  43                 internal extern static String FastAllocateString (int length);
  44
  45                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  46                 extern static String InternalIsInterned (String str);
  47
  48                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  49                 extern static String InternalIntern (String str);
  50
  51                 // TODO: Should be pointing to Buffer instead
  52                 #region Runtime method-to-ir dependencies
  53
  54                 static unsafe void memset (byte *dest, int val, int len)
  55                 {
  56                         if (len < 8) {
  57                                 while (len != 0) {
  58                                         *dest = (byte)val;
  59                                         ++dest;
  60                                         --len;
  61                                 }
  62                                 return;
  63                         }
  64                         if (val != 0) {
  65                                 val = val | (val << 8);
  66                                 val = val | (val << 16);
  67                         }
  68                         // align to 4
  69                         int rest = (int)dest & 3;
  70                         if (rest != 0) {
  71                                 rest = 4 - rest;
  72                                 len -= rest;
  73                                 do {
  74                                         *dest = (byte)val;
  75                                         ++dest;
  76                                         --rest;
  77                                 } while (rest != 0);
  78                         }
  79                         while (len >= 16) {
  80                                 ((int*)dest) [0] = val;
  81                                 ((int*)dest) [1] = val;
  82                                 ((int*)dest) [2] = val;
  83                                 ((int*)dest) [3] = val;
  84                                 dest += 16;
  85                                 len -= 16;
  86                         }
  87                         while (len >= 4) {
  88                                 ((int*)dest) [0] = val;
  89                                 dest += 4;
  90                                 len -= 4;
  91                         }
  92                         // tail bytes
  93                         while (len > 0) {
  94                                 *dest = (byte)val;
  95                                 dest++;
  96                                 len--;
  97                         }
  98                 }
  99
 100                 static unsafe void memcpy (byte *dest, byte *src, int size)
 101                 {
 102                         Buffer.Memcpy (dest, src, size);
 103                 }
 104
 105                 /* Used by the runtime */
 106                 internal static unsafe void bzero (byte *dest, int len) {
 107                         memset (dest, 0, len);
 108                 }
 109
 110                 internal static unsafe void bzero_aligned_1 (byte *dest, int len) {
 111                         ((byte*)dest) [0] = 0;
 112                 }
 113
 114                 internal static unsafe void bzero_aligned_2 (byte *dest, int len) {
 115                         ((short*)dest) [0] = 0;
 116                 }
 117
 118                 internal static unsafe void bzero_aligned_4 (byte *dest, int len) {
 119                         ((int*)dest) [0] = 0;
 120                 }
 121
 122                 internal static unsafe void bzero_aligned_8 (byte *dest, int len) {
 123                         ((long*)dest) [0] = 0;
 124                 }
 125
 126                 internal static unsafe void memcpy_aligned_1 (byte *dest, byte *src, int size) {
 127                         ((byte*)dest) [0] = ((byte*)src) [0];
 128                 }
 129
 130                 internal static unsafe void memcpy_aligned_2 (byte *dest, byte *src, int size) {
 131                         ((short*)dest) [0] = ((short*)src) [0];
 132                 }
 133
 134                 internal static unsafe void memcpy_aligned_4 (byte *dest, byte *src, int size) {
 135                         ((int*)dest) [0] = ((int*)src) [0];
 136                 }
 137
 138                 internal static unsafe void memcpy_aligned_8 (byte *dest, byte *src, int size) {
 139                         ((long*)dest) [0] = ((long*)src) [0];
 140                 }
 141
 142                 #endregion
 143
 144                 // Certain constructors are redirected to CreateString methods with
 145                 // matching argument list. The this pointer should not be used.
 146                 //
 147                 // TODO: Update runtime to call Ctor directly
 148
 149                 unsafe String CreateString (sbyte* value)
 150                 {
 151                         return Ctor (value);
 152                 }
 153
 154                 unsafe String CreateString (sbyte* value, int startIndex, int length)
 155                 {
 156                         return Ctor (value, startIndex, length);
 157                 }
 158
 159                 unsafe String CreateString (char* value)
 160                 {
 161                         return Ctor (value);
 162                 }
 163
 164                 unsafe String CreateString (char* value, int startIndex, int length)
 165                 {
 166                         return Ctor (value, startIndex, length);
 167                 }
 168
 169                 String CreateString (char[] val, int startIndex, int length)
 170                 {
 171                         return Ctor (val, startIndex, length);
 172                 }
 173
 174                 String CreateString (char [] val)
 175                 {
 176                         return Ctor (val);
 177                 }
 178
 179                 String CreateString (char c, int count)
 180                 {
 181                         return Ctor (c, count);
 182                 }
 183
 184                 unsafe String CreateString (sbyte* value, int startIndex, int length, System.Text.Encoding enc)
 185                 {
 186                         return Ctor (value, startIndex, length, enc);
 187                 }
 188
 189                 String CreateString (ReadOnlySpan<char> value)
 190                 {
 191                         return Ctor (value);
 192                 }
 193         }
 194 }