internal static string GetFullPath(string fileSpec, string currentDirectory)
{
fileSpec = EscapingUtilities.UnescapeAll(fileSpec);
string str = EscapingUtilities.Escape(NormalizePath(Path.Combine(currentDirectory, fileSpec)));
if (EndsWithSlash(str))
{
return(str);
}
Match match = FileUtilitiesRegex.DrivePattern.Match(fileSpec);
Match match2 = FileUtilitiesRegex.UNCPattern.Match(str);
if ((!match.Success || (match.Length != fileSpec.Length)) && (!match2.Success || (match2.Length != str.Length)))
{
return(str);
}
return(str + Path.DirectorySeparatorChar);
}
/// <summary>
/// Determines the full path for the given file-spec.
/// ASSUMES INPUT IS STILL ESCAPED
/// </summary>
/// <param name="fileSpec">The file spec to get the full path of.</param>
/// <param name="currentDirectory"></param>
/// <returns>full path</returns>
internal static string GetFullPath(string fileSpec, string currentDirectory)
{
// Sending data out of the engine into the filesystem, so time to unescape.
fileSpec = FixFilePath(EscapingUtilities.UnescapeAll(fileSpec));
// Data coming back from the filesystem into the engine, so time to escape it back.
string fullPath = EscapingUtilities.Escape(NormalizePath(Path.Combine(currentDirectory, fileSpec)));
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && !EndsWithSlash(fullPath))
{
if (FileUtilitiesRegex.IsDrivePattern(fileSpec) ||
FileUtilitiesRegex.IsUncPattern(fullPath))
{
// append trailing slash if Path.GetFullPath failed to (this happens with drive-specs and UNC shares)
fullPath += Path.DirectorySeparatorChar;
}
}
return(fullPath);
}
/// <summary>
/// Determines the full path for the given file-spec.
/// ASSUMES INPUT IS STILL ESCAPED
/// </summary>
/// <param name="fileSpec">The file spec to get the full path of.</param>
/// <param name="currentDirectory"></param>
/// <returns>full path</returns>
internal static string GetFullPath(string fileSpec, string currentDirectory)
{
// Sending data out of the engine into the filesystem, so time to unescape.
fileSpec = FixFilePath(EscapingUtilities.UnescapeAll(fileSpec));
// Data coming back from the filesystem into the engine, so time to escape it back.
string fullPath = EscapingUtilities.Escape(NormalizePath(Path.Combine(currentDirectory, fileSpec)));
if (NativeMethodsShared.IsWindows && !EndsWithSlash(fullPath))
{
Match drive = FileUtilitiesRegex.DrivePattern.Match(fileSpec);
Match UNCShare = FileUtilitiesRegex.UNCPattern.Match(fullPath);
if ((drive.Success && (drive.Length == fileSpec.Length)) ||
(UNCShare.Success && (UNCShare.Length == fullPath.Length)))
{
// append trailing slash if Path.GetFullPath failed to (this happens with drive-specs and UNC shares)
fullPath += Path.DirectorySeparatorChar;
}
}
return(fullPath);
}
internal static string GetItemSpecModifier(string currentDirectory, string itemSpec, string definingProjectEscaped, string modifier, ref string fullPath)
{
ErrorUtilities.VerifyThrow(itemSpec != null, "Need item-spec to modify.");
ErrorUtilities.VerifyThrow(modifier != null, "Need modifier to apply to item-spec.");
string modifiedItemSpec = null;
try
{
if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.FullPath, StringComparison.OrdinalIgnoreCase))
{
if (fullPath != null)
{
return(fullPath);
}
if (currentDirectory == null)
{
currentDirectory = String.Empty;
}
modifiedItemSpec = GetFullPath(itemSpec, currentDirectory);
fullPath = modifiedItemSpec;
ThrowForUrl(modifiedItemSpec, itemSpec, currentDirectory);
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.RootDir, StringComparison.OrdinalIgnoreCase))
{
GetItemSpecModifier(currentDirectory, itemSpec, definingProjectEscaped, ItemSpecModifiers.FullPath, ref fullPath);
modifiedItemSpec = Path.GetPathRoot(fullPath);
if (!EndsWithSlash(modifiedItemSpec))
{
ErrorUtilities.VerifyThrow(FileUtilitiesRegex.StartsWithUncPattern(modifiedItemSpec),
"Only UNC shares should be missing trailing slashes.");
// restore/append trailing slash if Path.GetPathRoot() has either removed it, or failed to add it
// (this happens with UNC shares)
modifiedItemSpec += Path.DirectorySeparatorChar;
}
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.Filename, StringComparison.OrdinalIgnoreCase))
{
// if the item-spec is a root directory, it can have no filename
if (IsRootDirectory(itemSpec))
{
// NOTE: this is to prevent Path.GetFileNameWithoutExtension() from treating server and share elements
// in a UNC file-spec as filenames e.g. \\server, \\server\share
modifiedItemSpec = String.Empty;
}
else
{
// Fix path to avoid problem with Path.GetFileNameWithoutExtension when backslashes in itemSpec on Unix
modifiedItemSpec = Path.GetFileNameWithoutExtension(FixFilePath(itemSpec));
}
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.Extension, StringComparison.OrdinalIgnoreCase))
{
// if the item-spec is a root directory, it can have no extension
if (IsRootDirectory(itemSpec))
{
// NOTE: this is to prevent Path.GetExtension() from treating server and share elements in a UNC
// file-spec as filenames e.g. \\server.ext, \\server\share.ext
modifiedItemSpec = String.Empty;
}
else
{
modifiedItemSpec = Path.GetExtension(itemSpec);
}
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.RelativeDir, StringComparison.OrdinalIgnoreCase))
{
modifiedItemSpec = GetDirectory(itemSpec);
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.Directory, StringComparison.OrdinalIgnoreCase))
{
GetItemSpecModifier(currentDirectory, itemSpec, definingProjectEscaped, ItemSpecModifiers.FullPath, ref fullPath);
modifiedItemSpec = GetDirectory(fullPath);
if (NativeMethodsShared.IsWindows)
{
int length = -1;
if (FileUtilitiesRegex.StartsWithDrivePattern(modifiedItemSpec))
{
length = 2;
}
else
{
length = FileUtilitiesRegex.StartsWithUncPatternMatchLength(modifiedItemSpec);
}
if (length != -1)
{
ErrorUtilities.VerifyThrow((modifiedItemSpec.Length > length) && IsSlash(modifiedItemSpec[length]),
"Root directory must have a trailing slash.");
modifiedItemSpec = modifiedItemSpec.Substring(length + 1);
}
}
else
{
ErrorUtilities.VerifyThrow(!string.IsNullOrEmpty(modifiedItemSpec) && IsSlash(modifiedItemSpec[0]),
"Expected a full non-windows path rooted at '/'.");
// A full unix path is always rooted at
// `/`, and a root-relative path is the
// rest of the string.
modifiedItemSpec = modifiedItemSpec.Substring(1);
}
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.RecursiveDir, StringComparison.OrdinalIgnoreCase))
{
// only the BuildItem class can compute this modifier -- so leave empty
modifiedItemSpec = String.Empty;
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.Identity, StringComparison.OrdinalIgnoreCase))
{
modifiedItemSpec = itemSpec;
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.ModifiedTime, StringComparison.OrdinalIgnoreCase))
{
// About to go out to the filesystem. This means data is leaving the engine, so need
// to unescape first.
string unescapedItemSpec = EscapingUtilities.UnescapeAll(itemSpec);
FileInfo info = FileUtilities.GetFileInfoNoThrow(unescapedItemSpec);
if (info != null)
{
modifiedItemSpec = info.LastWriteTime.ToString(FileTimeFormat, null);
}
else
{
// File does not exist, or path is a directory
modifiedItemSpec = String.Empty;
}
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.CreatedTime, StringComparison.OrdinalIgnoreCase))
{
// About to go out to the filesystem. This means data is leaving the engine, so need
// to unescape first.
string unescapedItemSpec = EscapingUtilities.UnescapeAll(itemSpec);
if (FileSystems.Default.FileExists(unescapedItemSpec))
{
modifiedItemSpec = File.GetCreationTime(unescapedItemSpec).ToString(FileTimeFormat, null);
}
else
{
// File does not exist, or path is a directory
modifiedItemSpec = String.Empty;
}
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.AccessedTime, StringComparison.OrdinalIgnoreCase))
{
// About to go out to the filesystem. This means data is leaving the engine, so need
// to unescape first.
string unescapedItemSpec = EscapingUtilities.UnescapeAll(itemSpec);
if (FileSystems.Default.FileExists(unescapedItemSpec))
{
modifiedItemSpec = File.GetLastAccessTime(unescapedItemSpec).ToString(FileTimeFormat, null);
}
else
{
// File does not exist, or path is a directory
modifiedItemSpec = String.Empty;
}
}
else if (IsDefiningProjectModifier(modifier))
{
if (String.IsNullOrEmpty(definingProjectEscaped))
{
// We have nothing to work with, but that's sometimes OK -- so just return String.Empty
modifiedItemSpec = String.Empty;
}
else
{
if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.DefiningProjectDirectory, StringComparison.OrdinalIgnoreCase))
{
// ItemSpecModifiers.Directory does not contain the root directory
modifiedItemSpec = Path.Combine
(
GetItemSpecModifier(currentDirectory, definingProjectEscaped, null, ItemSpecModifiers.RootDir),
GetItemSpecModifier(currentDirectory, definingProjectEscaped, null, ItemSpecModifiers.Directory)
);
}
else
{
string additionalModifier = null;
if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.DefiningProjectFullPath, StringComparison.OrdinalIgnoreCase))
{
additionalModifier = ItemSpecModifiers.FullPath;
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.DefiningProjectName, StringComparison.OrdinalIgnoreCase))
{
additionalModifier = ItemSpecModifiers.Filename;
}
else if (string.Equals(modifier, FileUtilities.ItemSpecModifiers.DefiningProjectExtension, StringComparison.OrdinalIgnoreCase))
{
additionalModifier = ItemSpecModifiers.Extension;
}
else
{
ErrorUtilities.ThrowInternalError("\"{0}\" is not a valid item-spec modifier.", modifier);
}
modifiedItemSpec = GetItemSpecModifier(currentDirectory, definingProjectEscaped, null, additionalModifier);
}
}
}
else
{
ErrorUtilities.ThrowInternalError("\"{0}\" is not a valid item-spec modifier.", modifier);
}
}
catch (Exception e) when(ExceptionHandling.IsIoRelatedException(e))
{
ErrorUtilities.VerifyThrowInvalidOperation(false, "Shared.InvalidFilespecForTransform", modifier, itemSpec, e.Message);
}
return(modifiedItemSpec);
}
internal static string GetItemSpecModifier(string currentDirectory, string itemSpec, string modifier, ref CopyOnWriteDictionary <string, string> cachedModifiers)
{
ErrorUtilities.VerifyThrow(itemSpec != null, "Need item-spec to modify.");
ErrorUtilities.VerifyThrow(modifier != null, "Need modifier to apply to item-spec.");
string fullPath = null;
if (cachedModifiers != null)
{
cachedModifiers.TryGetValue(modifier, out fullPath);
}
if (fullPath == null)
{
bool flag = true;
try
{
if (string.Compare(modifier, "FullPath", StringComparison.OrdinalIgnoreCase) == 0)
{
if (currentDirectory == null)
{
currentDirectory = string.Empty;
}
fullPath = FileUtilities.GetFullPath(itemSpec, currentDirectory);
ThrowForUrl(fullPath, itemSpec, currentDirectory);
}
else if (string.Compare(modifier, "RootDir", StringComparison.OrdinalIgnoreCase) == 0)
{
string str2;
if (currentDirectory == null)
{
currentDirectory = string.Empty;
}
if ((cachedModifiers == null) || !cachedModifiers.TryGetValue("FullPath", out str2))
{
str2 = FileUtilities.GetFullPath(itemSpec, currentDirectory);
ThrowForUrl(str2, itemSpec, currentDirectory);
}
fullPath = Path.GetPathRoot(str2);
if (!FileUtilities.EndsWithSlash(fullPath))
{
ErrorUtilities.VerifyThrow(FileUtilitiesRegex.UNCPattern.IsMatch(fullPath), "Only UNC shares should be missing trailing slashes.");
fullPath = fullPath + Path.DirectorySeparatorChar;
}
}
else if (string.Compare(modifier, "Filename", StringComparison.OrdinalIgnoreCase) == 0)
{
if (Path.GetDirectoryName(itemSpec) == null)
{
fullPath = string.Empty;
}
else
{
fullPath = Path.GetFileNameWithoutExtension(itemSpec);
}
}
else if (string.Compare(modifier, "Extension", StringComparison.OrdinalIgnoreCase) == 0)
{
if (Path.GetDirectoryName(itemSpec) == null)
{
fullPath = string.Empty;
}
else
{
fullPath = Path.GetExtension(itemSpec);
}
}
else if (string.Compare(modifier, "RelativeDir", StringComparison.OrdinalIgnoreCase) == 0)
{
fullPath = FileUtilities.GetDirectory(itemSpec);
}
else if (string.Compare(modifier, "Directory", StringComparison.OrdinalIgnoreCase) == 0)
{
string str3;
if (currentDirectory == null)
{
currentDirectory = string.Empty;
}
if ((cachedModifiers == null) || !cachedModifiers.TryGetValue("FullPath", out str3))
{
str3 = FileUtilities.GetFullPath(itemSpec, currentDirectory);
ThrowForUrl(str3, itemSpec, currentDirectory);
}
fullPath = FileUtilities.GetDirectory(str3);
Match match = FileUtilitiesRegex.DrivePattern.Match(fullPath);
if (!match.Success)
{
match = FileUtilitiesRegex.UNCPattern.Match(fullPath);
}
if (match.Success)
{
ErrorUtilities.VerifyThrow((fullPath.Length > match.Length) && FileUtilities.IsSlash(fullPath[match.Length]), "Root directory must have a trailing slash.");
fullPath = fullPath.Substring(match.Length + 1);
}
}
else if (string.Compare(modifier, "RecursiveDir", StringComparison.OrdinalIgnoreCase) == 0)
{
fullPath = string.Empty;
}
else if (string.Compare(modifier, "Identity", StringComparison.OrdinalIgnoreCase) == 0)
{
flag = cachedModifiers != null;
fullPath = itemSpec;
}
else if (string.Compare(modifier, "ModifiedTime", StringComparison.OrdinalIgnoreCase) == 0)
{
flag = false;
FileInfo fileInfoNoThrow = FileUtilities.GetFileInfoNoThrow(EscapingUtilities.UnescapeAll(itemSpec));
if (fileInfoNoThrow != null)
{
fullPath = fileInfoNoThrow.LastWriteTime.ToString("yyyy'-'MM'-'dd HH':'mm':'ss'.'fffffff", null);
}
else
{
fullPath = string.Empty;
}
}
else if (string.Compare(modifier, "CreatedTime", StringComparison.OrdinalIgnoreCase) == 0)
{
flag = false;
string path = EscapingUtilities.UnescapeAll(itemSpec);
if (File.Exists(path))
{
fullPath = File.GetCreationTime(path).ToString("yyyy'-'MM'-'dd HH':'mm':'ss'.'fffffff", null);
}
else
{
fullPath = string.Empty;
}
}
else if (string.Compare(modifier, "AccessedTime", StringComparison.OrdinalIgnoreCase) == 0)
{
flag = false;
string str6 = EscapingUtilities.UnescapeAll(itemSpec);
if (File.Exists(str6))
{
fullPath = File.GetLastAccessTime(str6).ToString("yyyy'-'MM'-'dd HH':'mm':'ss'.'fffffff", null);
}
else
{
fullPath = string.Empty;
}
}
else
{
ErrorUtilities.VerifyThrow(false, "\"{0}\" is not a valid item-spec modifier.", modifier);
}
}
catch (Exception exception)
{
if (ExceptionHandling.NotExpectedException(exception))
{
throw;
}
ErrorUtilities.VerifyThrowInvalidOperation(false, "Shared.InvalidFilespecForTransform", modifier, itemSpec, exception.Message);
}
ErrorUtilities.VerifyThrow(fullPath != null, "The item-spec modifier \"{0}\" was not evaluated.", modifier);
if (flag)
{
if (cachedModifiers == null)
{
cachedModifiers = new CopyOnWriteDictionary <string, string>(StringComparer.OrdinalIgnoreCase);
}
cachedModifiers[modifier] = fullPath;
}
}
return(fullPath);
}