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); }