/// <summary> /// Check if string is prefixed by psdrive, if so, expand it if filesystem path. /// </summary> /// <param name="path">The potential PSPath to resolve.</param> /// <param name="context">The current ExecutionContext.</param> /// <returns>Resolved PSPath if applicable otherwise the original path</returns> internal static string ResolvePath(string path, ExecutionContext context) { if (ExperimentalFeature.IsEnabled("PSNativePSPathResolution")) { #if !UNIX // on Windows, we need to expand ~ to point to user's home path if (string.Equals(path, "~", StringComparison.Ordinal) || path.StartsWith(TildeDirectorySeparator, StringComparison.Ordinal) || path.StartsWith(TildeAltDirectorySeparator, StringComparison.Ordinal)) { try { ProviderInfo fileSystemProvider = context.EngineSessionState.GetSingleProvider(FileSystemProvider.ProviderName); return(new StringBuilder(fileSystemProvider.Home) .Append(path.Substring(1)) .Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar) .ToString()); } catch { return(path); } } // check if the driveName is an actual disk drive on Windows, if so, no expansion if (path.Length >= 2 && path[1] == ':') { foreach (var drive in DriveInfo.GetDrives()) { if (drive.Name.StartsWith(new string(path[0], 1), StringComparison.OrdinalIgnoreCase)) { return(path); } } } #endif if (path.Contains(':')) { LocationGlobber globber = new LocationGlobber(context.SessionState); try { ProviderInfo providerInfo; // replace the argument with resolved path if it's a filesystem path string pspath = globber.GetProviderPath(path, out providerInfo); if (string.Equals(providerInfo.Name, FileSystemProvider.ProviderName, StringComparison.OrdinalIgnoreCase)) { path = pspath; } } catch { // if it's not a provider path, do nothing } } } return(path); }
private static List <Hashtable> InitializeSuggestions() { var suggestions = new List <Hashtable>( new Hashtable[] { NewSuggestion( id: 1, category: "Transactions", matchType: SuggestionMatchType.Command, rule: "^Start-Transaction", suggestion: SuggestionStrings.Suggestion_StartTransaction, enabled: true), NewSuggestion( id: 2, category: "Transactions", matchType: SuggestionMatchType.Command, rule: "^Use-Transaction", suggestion: SuggestionStrings.Suggestion_UseTransaction, enabled: true), NewSuggestion( id: 3, category: "General", matchType: SuggestionMatchType.Dynamic, rule: ScriptBlock.CreateDelayParsedScriptBlock(s_checkForCommandInCurrentDirectoryScript, isProductCode: true), suggestion: ScriptBlock.CreateDelayParsedScriptBlock(s_createCommandExistsInCurrentDirectoryScript, isProductCode: true), suggestionArgs: new object[] { CodeGeneration.EscapeSingleQuotedStringContent(SuggestionStrings.Suggestion_CommandExistsInCurrentDirectory) }, enabled: true) }); if (ExperimentalFeature.IsEnabled("PSCommandNotFoundSuggestion")) { suggestions.Add( NewSuggestion( id: 4, category: "General", matchType: SuggestionMatchType.ErrorId, rule: "CommandNotFoundException", suggestion: ScriptBlock.CreateDelayParsedScriptBlock(s_getFuzzyMatchedCommands, isProductCode: true), suggestionArgs: new object[] { CodeGeneration.EscapeSingleQuotedStringContent(SuggestionStrings.Suggestion_CommandNotFound) }, enabled: true)); } return(suggestions); }
internal void BindParameters(Collection <CommandParameterInternal> parameters) { bool sawVerbatimArgumentMarker = false; bool first = true; foreach (CommandParameterInternal parameter in parameters) { if (!first) { _arguments.Append(' '); } first = false; if (parameter.ParameterNameSpecified) { Diagnostics.Assert(!parameter.ParameterText.Contains(' '), "Parameters cannot have whitespace"); PossiblyGlobArg(parameter.ParameterText, parameter, StringConstantType.BareWord); if (parameter.SpaceAfterParameter) { _arguments.Append(' '); } } if (parameter.ArgumentSpecified) { // If this is the verbatim argument marker, we don't pass it on to the native command. // We do need to remember it though - we'll expand environment variables in subsequent args. object argValue = parameter.ArgumentValue; if (string.Equals("--%", argValue as string, StringComparison.OrdinalIgnoreCase)) { sawVerbatimArgumentMarker = true; continue; } if (argValue != AutomationNull.Value && argValue != UnboundParameter.Value) { // ArrayLiteralAst is used to reconstruct the correct argument, e.g. // windbg -k com:port=\\devbox\pipe\debug,pipe,resets=0,reconnect // The parser produced an array of strings but marked the parameter so we // can properly reconstruct the correct command line. StringConstantType stringConstantType = StringConstantType.BareWord; ArrayLiteralAst arrayLiteralAst = null; switch (parameter?.ArgumentAst) { case StringConstantExpressionAst sce: stringConstantType = sce.StringConstantType; break; case ExpandableStringExpressionAst ese: stringConstantType = ese.StringConstantType; break; case ArrayLiteralAst ala: arrayLiteralAst = ala; break; } // Prior to PSNativePSPathResolution experimental feature, a single quote worked the same as a double quote // so if the feature is not enabled, we treat any quotes as double quotes. When this feature is no longer // experimental, this code here needs to be removed. if (!ExperimentalFeature.IsEnabled("PSNativePSPathResolution") && stringConstantType == StringConstantType.SingleQuoted) { stringConstantType = StringConstantType.DoubleQuoted; } AppendOneNativeArgument(Context, parameter, argValue, arrayLiteralAst, sawVerbatimArgumentMarker, stringConstantType); } } } }