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