public static ReadOnlySpan <char> GetFileName(ReadOnlySpan <char> path)
{
int length1 = Path.GetPathRoot(path).Length;
int length2 = path.Length;
while (--length2 >= 0)
{
if (length2 < length1 || PathInternal.IsDirectorySeparator(path[length2]))
{
return(path.Slice(length2 + 1, path.Length - length2 - 1));
}
}
return(path);
}
public static string GetTempPath()
{
const string TempEnvVar = "TMPDIR";
// Get the temp path from the TMPDIR environment variable.
// If it's not set, just return the default path.
// If it is, return it, ensuring it ends with a slash.
string?path = Environment.GetEnvironmentVariable(TempEnvVar);
return
(string.IsNullOrEmpty(path) ? DefaultTempPath :
PathInternal.IsDirectorySeparator(path[path.Length - 1]) ? path :
path + PathInternal.DirectorySeparatorChar);
}
// Token: 0x0600195B RID: 6491 RVA: 0x00054644 File Offset: 0x00052844
internal static int PathStartSkip(string path)
{
int num = 0;
while (num < path.Length && path[num] == ' ')
{
num++;
}
if ((num > 0 && num < path.Length && PathInternal.IsDirectorySeparator(path[num])) || (num + 1 < path.Length && path[num + 1] == Path.VolumeSeparatorChar && PathInternal.IsValidDriveChar(path[num])))
{
return(num);
}
return(0);
}
internal static int GetCommonPathLength(string first, string second, bool ignoreCase)
{
int index = PathInternal.EqualStartingCharacterCount(first, second, ignoreCase);
if (index == 0 || index == first.Length && (index == second.Length || PathInternal.IsDirectorySeparator(second[index])) || index == second.Length && PathInternal.IsDirectorySeparator(first[index]))
{
return(index);
}
while (index > 0 && !PathInternal.IsDirectorySeparator(first[index - 1]))
{
--index;
}
return(index);
}
public static string Join(params string?[] paths)
{
if (paths == null)
{
throw new ArgumentNullException(nameof(paths));
}
if (paths.Length == 0)
{
return(string.Empty);
}
int maxSize = 0;
foreach (string?path in paths)
{
maxSize += path?.Length ?? 0;
}
maxSize += paths.Length - 1;
var builder = new ValueStringBuilder(stackalloc char[260]); // MaxShortPath on Windows
builder.EnsureCapacity(maxSize);
for (int i = 0; i < paths.Length; i++)
{
string?path = paths[i];
if (string.IsNullOrEmpty(path))
{
continue;
}
if (builder.Length == 0)
{
builder.Append(path);
}
else
{
if (!PathInternal.IsDirectorySeparator(builder[builder.Length - 1]) && !PathInternal.IsDirectorySeparator(path[0]))
{
builder.Append(PathInternal.DirectorySeparatorChar);
}
builder.Append(path);
}
}
return(builder.ToString());
}
public static bool IsPathRooted(string path)
{
// Want to avoid PathInternal.CheckInvalidPathChars on Path.IsPathRooted
if (path != null)
{
int length = path.Length;
if ((length >= 1 && PathInternal.IsDirectorySeparator(path[0])) ||
(length >= 2 && PathInternal.IsValidDriveChar(path[0]) && path[1] == Path.VolumeSeparatorChar))
{
return(true);
}
}
return(false);
}
// Tests if the given path contains a root. A path is considered rooted
// if it starts with a backslash ("\") or a drive letter and a colon (":").
public static bool IsPathRooted(string path)
{
if (path != null)
{
PathInternal.CheckInvalidPathChars(path);
int length = path.Length;
if ((length >= 1 && PathInternal.IsDirectorySeparator(path[0])) ||
(length >= 2 && path[1] == VolumeSeparatorChar))
{
return(true);
}
}
return(false);
}
internal static unsafe string NormalizeDirectorySeparators(string path)
{
if (string.IsNullOrEmpty(path))
{
return(path);
}
bool flag = true;
for (int index = 0; index < path.Length; ++index)
{
char c = path[index];
if (PathInternal.IsDirectorySeparator(c) && (c != '\\' || index > 0 && index + 1 < path.Length && PathInternal.IsDirectorySeparator(path[index + 1])))
{
flag = false;
break;
}
}
if (flag)
{
return(path);
}
// ISSUE: untyped stack allocation
ValueStringBuilder valueStringBuilder = new ValueStringBuilder(new Span <char>((void *)__untypedstackalloc(new IntPtr(520)), 260));
int index1 = 0;
if (PathInternal.IsDirectorySeparator(path[index1]))
{
++index1;
valueStringBuilder.Append('\\');
}
for (int index2 = index1; index2 < path.Length; ++index2)
{
char c = path[index2];
if (PathInternal.IsDirectorySeparator(c))
{
if (index2 + 1 >= path.Length || !PathInternal.IsDirectorySeparator(path[index2 + 1]))
{
c = '\\';
}
else
{
continue;
}
}
valueStringBuilder.Append(c);
}
return(valueStringBuilder.ToString());
}
public static bool HasExtension(ReadOnlySpan <char> path)
{
for (int index = path.Length - 1; index >= 0; --index)
{
char c = path[index];
if (c == '.')
{
return(index != path.Length - 1);
}
if (PathInternal.IsDirectorySeparator(c))
{
break;
}
}
return(false);
}
public static bool HasExtension(ReadOnlySpan <char> path)
{
for (int i = path.Length - 1; i >= 0; i--)
{
char ch = path[i];
if (ch == '.')
{
return(i != path.Length - 1);
}
if (PathInternal.IsDirectorySeparator(ch))
{
break;
}
}
return(false);
}
private static bool DoesItemExist(ReadOnlySpan <char> path, bool isFile)
{
if (path.IsEmpty || path.Length == 0)
{
return(false);
}
if (!isFile)
{
return(FileSystem.DirectoryExists(path));
}
return(PathInternal.IsDirectorySeparator(path[path.Length - 1])
? false
: FileSystem.FileExists(path));
}
private static String GetFullSearchString(String fullPath, String searchPattern)
{
Contract.Requires(fullPath != null);
Contract.Requires(searchPattern != null);
String tempStr = Path.Combine(fullPath, searchPattern);
// If path ends in a trailing slash (\), append a * or we'll get a "Cannot find the file specified" exception
char lastChar = tempStr[tempStr.Length - 1];
if (PathInternal.IsDirectorySeparator(lastChar) || lastChar == Path.VolumeSeparatorChar)
{
tempStr = tempStr + '*';
}
return(tempStr);
}
private unsafe static uint GetRootLength(char *path, ulong pathLength)
{
uint num = 0U;
uint num2 = 2U;
uint num3 = 2U;
bool flag = PathInternal.StartsWithOrdinal(path, pathLength, "\\\\?\\");
bool flag2 = PathInternal.StartsWithOrdinal(path, pathLength, "\\\\?\\UNC\\");
if (flag)
{
if (flag2)
{
num3 = (uint)"\\\\?\\UNC\\".Length;
}
else
{
num2 += (uint)"\\\\?\\".Length;
}
}
if ((!flag || flag2) && pathLength > 0UL && PathInternal.IsDirectorySeparator(*path))
{
num = 1U;
if (flag2 || (pathLength > 1UL && PathInternal.IsDirectorySeparator(path[1])))
{
num = num3;
int num4 = 2;
while ((ulong)num < pathLength)
{
if (PathInternal.IsDirectorySeparator(path[(ulong)num * 2UL / 2UL]) && --num4 <= 0)
{
break;
}
num += 1U;
}
}
}
else if (pathLength >= (ulong)num2 && path[(ulong)(num2 - 1U) * 2UL / 2UL] == Path.VolumeSeparatorChar)
{
num = num2;
if (pathLength >= (ulong)(num2 + 1U) && PathInternal.IsDirectorySeparator(path[(ulong)num2 * 2UL / 2UL]))
{
num += 1U;
}
}
return(num);
}
// ".." can only be used if it is specified as a part of a valid File/Directory name. We disallow
// the user being able to use it to move up directories. Here are some examples eg
// Valid: a..b abc..d
// Invalid: ..ab ab.. .. abc..d\abc..
//
internal static void CheckSearchPattern(string searchPattern)
{
for (int index = 0; (index = searchPattern.IndexOf("..", index, StringComparison.Ordinal)) != -1; index += 2)
{
// Terminal ".." or "..\". File and directory names cannot end in "..".
if (index + 2 == searchPattern.Length ||
PathInternal.IsDirectorySeparator(searchPattern[index + 2]))
{
throw new ArgumentException(SR.Arg_InvalidSearchPattern, nameof(searchPattern));
}
}
if (searchPattern.Length >= PathInternal.MaxComponentLength)
{
throw new PathTooLongException(SR.IO_PathTooLong);
}
}
/// <summary>
/// The returned ReadOnlySpan contains the characters of the path that follows the last separator in path.
/// </summary>
public static ReadOnlySpan <char> GetFileName(ReadOnlySpan <char> path)
{
int root = GetPathRoot(path).Length;
// We don't want to cut off "C:\file.txt:stream" (i.e. should be "file.txt:stream")
// but we *do* want "C:Foo" => "Foo". This necessitates checking for the root.
for (int i = path.Length; --i >= 0;)
{
if (i < root || PathInternal.IsDirectorySeparator(path[i]))
{
return(path.Slice(i + 1, path.Length - i - 1));
}
}
return(path);
}
internal static int GetRootLength(ReadOnlySpan <char> path)
{
int length = path.Length;
int index = 0;
bool flag1 = PathInternal.IsDevice(path);
bool flag2 = flag1 && PathInternal.IsDeviceUNC(path);
if (!flag1 | flag2 && length > 0 && PathInternal.IsDirectorySeparator(path[0]))
{
if (flag2 || length > 1 && PathInternal.IsDirectorySeparator(path[1]))
{
index = flag2 ? 8 : 2;
int num = 2;
while (index < length && (!PathInternal.IsDirectorySeparator(path[index]) || --num > 0))
{
++index;
}
}
else
{
index = 1;
}
}
else if (flag1)
{
index = 4;
while (index < length && !PathInternal.IsDirectorySeparator(path[index]))
{
++index;
}
if (index < length && index > 4 && PathInternal.IsDirectorySeparator(path[index]))
{
++index;
}
}
else if (length >= 2 && path[1] == ':' && PathInternal.IsValidDriveChar(path[0]))
{
index = 2;
if (length > 2 && PathInternal.IsDirectorySeparator(path[2]))
{
++index;
}
}
return(index);
}
internal static string GetFullSearchString(string fullPath, string searchPattern)
{
Debug.Assert(fullPath != null);
Debug.Assert(searchPattern != null);
ThrowIfEmptyOrRootedPath(searchPattern);
string tempStr = Path.Combine(fullPath, searchPattern);
// If path ends in a trailing slash (\), append a * or we'll get a "Cannot find the file specified" exception
char lastChar = tempStr[tempStr.Length - 1];
if (PathInternal.IsDirectorySeparator(lastChar) || lastChar == Path.VolumeSeparatorChar)
{
tempStr = tempStr + "*";
}
return(tempStr);
}
// Token: 0x06001945 RID: 6469 RVA: 0x00053FCC File Offset: 0x000521CC
internal static bool AreSegmentsTooLong(string fullPath)
{
int length = fullPath.Length;
int num = 0;
for (int i = 0; i < length; i++)
{
if (PathInternal.IsDirectorySeparator(fullPath[i]))
{
if (i - num > PathInternal.MaxComponentLength)
{
return(true);
}
num = i;
}
}
return(length - 1 - num > PathInternal.MaxComponentLength);
}
/// <summary>
/// Returns the characters to skip at the start of the path if it starts with space(s) and a drive or directory separator.
/// (examples are " C:", " \")
/// This is a legacy behavior of Path.GetFullPath().
/// </summary>
/// <remarks>
/// Note that this conflicts with IsPathRooted() which doesn't (and never did) such a skip.
/// </remarks>
internal static int PathStartSkip(string path)
{
int startIndex = 0;
while (startIndex < path.Length && path[startIndex] == ' ')
{
startIndex++;
}
if (startIndex > 0 && (startIndex < path.Length && PathInternal.IsDirectorySeparator(path[startIndex])) ||
(startIndex + 1 < path.Length && path[startIndex + 1] == ':' && PathInternal.IsValidDriveChar(path[startIndex])))
{
// Go ahead and skip spaces as we're either " C:" or " \"
return(startIndex);
}
return(0);
}
public static ReadOnlySpan <char> GetExtension(ReadOnlySpan <char> path)
{
int length = path.Length;
for (int start = length - 1; start >= 0; --start)
{
char c = path[start];
if (c == '.')
{
return(start != length - 1 ? path.Slice(start, length - start) : ReadOnlySpan <char> .Empty);
}
if (PathInternal.IsDirectorySeparator(c))
{
break;
}
}
return(ReadOnlySpan <char> .Empty);
}
private static bool InternalExistsHelper(String path, bool checkHost)
{
try
{
if (path == null)
{
return(false);
}
if (path.Length == 0)
{
return(false);
}
path = Path.GetFullPath(path);
// After normalizing, check whether path ends in directory separator.
// Otherwise, FillAttributeInfo removes it and we may return a false positive.
// GetFullPath should never return null
Contract.Assert(path != null, "File.Exists: GetFullPath returned null");
if (path.Length > 0 && PathInternal.IsDirectorySeparator(path[path.Length - 1]))
{
return(false);
}
#if FEATURE_CORECLR
if (checkHost)
{
FileSecurityState state = new FileSecurityState(FileSecurityStateAccess.Read, String.Empty, path);
state.EnsureState();
}
#else
FileIOPermission.QuickDemand(FileIOPermissionAccess.Read, path, false, false);
#endif
return(InternalExists(path));
}
catch (ArgumentException) { }
catch (NotSupportedException) { } // Security can throw this on ":"
catch (SecurityException) { }
catch (IOException) { }
catch (UnauthorizedAccessException) { }
return(false);
}
private static int GetDirectoryNameOffset(ReadOnlySpan <char> path)
{
int rootLength = PathInternal.GetRootLength(path);
int length = path.Length;
if (length <= rootLength)
{
return(-1);
}
do
{
;
}while (length > rootLength && !PathInternal.IsDirectorySeparator(path[--length]));
while (length > rootLength && PathInternal.IsDirectorySeparator(path[length - 1]))
{
--length;
}
return(length);
}
public static unsafe string Join([Nullable(new byte[] { 1, 2 })] params string[] paths)
{
if (paths == null)
{
throw new ArgumentNullException(nameof(paths));
}
if (paths.Length == 0)
{
return(string.Empty);
}
int num = 0;
foreach (string path in paths)
{
num += path != null ? path.Length : 0;
}
int capacity = num + (paths.Length - 1);
// ISSUE: untyped stack allocation
ValueStringBuilder valueStringBuilder = new ValueStringBuilder(new Span <char>((void *)__untypedstackalloc(new IntPtr(520)), 260));
valueStringBuilder.EnsureCapacity(capacity);
for (int index = 0; index < paths.Length; ++index)
{
string path = paths[index];
if (path != null && path.Length != 0)
{
if (valueStringBuilder.Length == 0)
{
valueStringBuilder.Append(path);
}
else
{
if (!PathInternal.IsDirectorySeparator(valueStringBuilder[valueStringBuilder.Length - 1]) && !PathInternal.IsDirectorySeparator(path[0]))
{
valueStringBuilder.Append('\\');
}
valueStringBuilder.Append(path);
}
}
}
return(valueStringBuilder.ToString());
}
// Returns the directory path of a file path. This method effectively
// removes the last element of the given file path, i.e. it returns a
// string consisting of all characters up to but not including the last
// backslash ("\") in the file path. The returned value is null if the file
// path is null or if the file path denotes a root (such as "\", "C:", or
// "\\server\share").
public static string GetDirectoryName(string path)
{
if (path != null)
{
PathInternal.CheckInvalidPathChars(path);
path = PathInternal.NormalizeDirectorySeparators(path);
int root = PathInternal.GetRootLength(path);
int i = path.Length;
if (i > root)
{
while (i > root && !PathInternal.IsDirectorySeparator(path[--i]))
{
;
}
return(path.Substring(0, i));
}
}
return(null);
}
public static string?ChangeExtension(string?path, string?extension)
{
if (path == null)
{
return(null);
}
int subLength = path.Length;
if (subLength == 0)
{
return(string.Empty);
}
for (int i = path.Length - 1; i >= 0; i--)
{
char ch = path[i];
if (ch == '.')
{
subLength = i;
break;
}
if (PathInternal.IsDirectorySeparator(ch))
{
break;
}
}
if (extension == null)
{
return(path.Substring(0, subLength));
}
ReadOnlySpan <char> subpath = path.AsSpan(0, subLength);
return(extension.StartsWith('.') ?
string.Concat(subpath, extension) :
string.Concat(subpath, ".", extension));
}
private static string GetNormalizedSearchCriteria(string fullSearchString, string fullPathMod)
{
Contract.Requires(fullSearchString != null);
Contract.Requires(fullPathMod != null);
Contract.Requires(fullSearchString.Length >= fullPathMod.Length);
string searchCriteria = null;
char lastChar = fullPathMod[fullPathMod.Length - 1];
if (PathInternal.IsDirectorySeparator(lastChar))
{
// Can happen if the path is C:\temp, in which case GetDirectoryName would return C:\
searchCriteria = fullSearchString.Substring(fullPathMod.Length);
}
else
{
Debug.Assert(fullSearchString.Length > fullPathMod.Length);
searchCriteria = fullSearchString.Substring(fullPathMod.Length + 1);
}
return(searchCriteria);
}
public static ReadOnlySpan <char> GetDirectoryNameNoChecks(ReadOnlySpan <char> path)
{
if (path.Length == 0)
{
return(ReadOnlySpan <char> .Empty);
}
int root = PathInternal.GetRootLength(path);
int i = path.Length;
if (i > root)
{
while (i > root && !PathInternal.IsDirectorySeparator(path[--i]))
{
;
}
return(path.Slice(0, i));
}
return(ReadOnlySpan <char> .Empty);
}
private unsafe static string CombineNoChecksInternal(ReadOnlySpan <char> first, ReadOnlySpan <char> second, ReadOnlySpan <char> third, ReadOnlySpan <char> fourth)
{
Debug.Assert(first.Length > 0 && second.Length > 0 && third.Length > 0 && fourth.Length > 0, "should have dealt with empty paths");
bool firstHasSeparator = PathInternal.IsDirectorySeparator(first[first.Length - 1]) ||
PathInternal.IsDirectorySeparator(second[0]);
bool thirdHasSeparator = PathInternal.IsDirectorySeparator(second[second.Length - 1]) ||
PathInternal.IsDirectorySeparator(third[0]);
bool fourthHasSeparator = PathInternal.IsDirectorySeparator(third[third.Length - 1]) ||
PathInternal.IsDirectorySeparator(fourth[0]);
fixed(char *f = &MemoryMarshal.GetReference(first), s = &MemoryMarshal.GetReference(second), t = &MemoryMarshal.GetReference(third), u = &MemoryMarshal.GetReference(fourth))
{
return(string.Create(
first.Length + second.Length + third.Length + fourth.Length + (firstHasSeparator ? 0 : 1) + (thirdHasSeparator ? 0 : 1) + (fourthHasSeparator ? 0 : 1),
(First: (IntPtr)f, FirstLength: first.Length, Second: (IntPtr)s, SecondLength: second.Length,
Third: (IntPtr)t, ThirdLength: third.Length, Fourth: (IntPtr)u, FourthLength: fourth.Length,
FirstHasSeparator: firstHasSeparator, ThirdHasSeparator: thirdHasSeparator, FourthHasSeparator: fourthHasSeparator),
(destination, state) =>
{
new Span <char>((char *)state.First, state.FirstLength).CopyTo(destination);
if (!state.FirstHasSeparator)
{
destination[state.FirstLength] = PathInternal.DirectorySeparatorChar;
}
new Span <char>((char *)state.Second, state.SecondLength).CopyTo(destination.Slice(state.FirstLength + (state.FirstHasSeparator ? 0 : 1)));
if (!state.ThirdHasSeparator)
{
destination[state.FirstLength + state.SecondLength + (state.FirstHasSeparator ? 0 : 1)] = PathInternal.DirectorySeparatorChar;
}
new Span <char>((char *)state.Third, state.ThirdLength).CopyTo(destination.Slice(state.FirstLength + state.SecondLength + (state.FirstHasSeparator ? 0 : 1) + (state.ThirdHasSeparator ? 0 : 1)));
if (!state.FourthHasSeparator)
{
destination[destination.Length - state.FourthLength - 1] = PathInternal.DirectorySeparatorChar;
}
new Span <char>((char *)state.Fourth, state.FourthLength).CopyTo(destination.Slice(destination.Length - state.FourthLength));
}));
}
}
private unsafe static string CombineNoChecksInternal(ReadOnlySpan <char> first, ReadOnlySpan <char> second)
{
Debug.Assert(first.Length > 0 && second.Length > 0, "should have dealt with empty paths");
bool hasSeparator = PathInternal.IsDirectorySeparator(first[first.Length - 1]) ||
PathInternal.IsDirectorySeparator(second[0]);
fixed(char *f = &first.DangerousGetPinnableReference(), s = &second.DangerousGetPinnableReference())
{
return(string.Create(
first.Length + second.Length + (hasSeparator ? 0 : 1),
(First: (IntPtr)f, FirstLength: first.Length, Second: (IntPtr)s, SecondLength: second.Length, HasSeparator: hasSeparator),
(destination, state) =>
{
new Span <char>((char *)state.First, state.FirstLength).CopyTo(destination);
if (!state.HasSeparator)
{
destination[state.FirstLength] = Path.DirectorySeparatorChar;
}
new Span <char>((char *)state.Second, state.SecondLength).CopyTo(destination.Slice(state.FirstLength + (state.HasSeparator ? 0 : 1)));
}));
}
}
internal static int GetDirectoryNameOffset(ReadOnlySpan <char> path)
{
int rootLength = PathInternal.GetRootLength(path);
int end = path.Length;
if (end <= rootLength)
{
return(-1);
}
while (end > rootLength && !PathInternal.IsDirectorySeparator(path[--end]))
{
;
}
// Trim off any remaining separators (to deal with C:\foo\\bar)
while (end > rootLength && PathInternal.IsDirectorySeparator(path[end - 1]))
{
end--;
}
return(end);
}
