internal static void AddArgumentsToCommandProcessor(CommandProcessorBase commandProcessor, object[] arguments) { if (arguments != null) { for (int i = 0; i < arguments.Length; i++) { CommandParameterInternal internal2; string arg = arguments[i] as string; if (ArgumentLooksLikeParameter(arg)) { int index = arg.IndexOf(':'); if ((index != -1) && (index != (arg.Length - 1))) { internal2 = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, arg.Substring(1, index - 1), arg, PositionUtilities.EmptyExtent, arg.Substring(index + 1).Trim(), false); } else if ((i == (arguments.Length - 1)) || (arg[arg.Length - 1] != ':')) { internal2 = CommandParameterInternal.CreateParameter(PositionUtilities.EmptyExtent, arg.Substring(1), arg); } else { internal2 = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, arg.Substring(1, arg.Length - 2), arg, PositionUtilities.EmptyExtent, arguments[i + 1], false); i++; } } else { internal2 = CommandParameterInternal.CreateArgument(PositionUtilities.EmptyExtent, arguments[i], false); } commandProcessor.AddParameter(internal2); } } }
internal static SteppablePipeline GetSteppablePipeline(PipelineAst pipelineAst, CommandOrigin commandOrigin) { PipelineProcessor pipe = new PipelineProcessor(); System.Management.Automation.ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS(); foreach (CommandAst ast in pipelineAst.PipelineElements.Cast <CommandAst>()) { List <CommandParameterInternal> list = new List <CommandParameterInternal>(); foreach (CommandElementAst ast2 in ast.CommandElements) { CommandParameterAst commandParameterAst = ast2 as CommandParameterAst; if (commandParameterAst != null) { list.Add(GetCommandParameter(commandParameterAst, executionContextFromTLS)); } else { ExpressionAst expressionAst = (ExpressionAst)ast2; object obj2 = Compiler.GetExpressionValue(expressionAst, executionContextFromTLS, (IList)null); bool splatted = (expressionAst is VariableExpressionAst) && ((VariableExpressionAst)expressionAst).Splatted; list.Add(CommandParameterInternal.CreateArgument(expressionAst.Extent, obj2, splatted)); } } List <CommandRedirection> list2 = new List <CommandRedirection>(); foreach (RedirectionAst ast5 in ast.Redirections) { list2.Add(GetCommandRedirection(ast5, executionContextFromTLS)); } CommandProcessorBase base2 = AddCommand(pipe, list.ToArray(), ast, list2.ToArray(), executionContextFromTLS); base2.Command.CommandOriginInternal = commandOrigin; base2.CommandScope.ScopeOrigin = commandOrigin; base2.Command.MyInvocation.CommandOrigin = commandOrigin; CallStackFrame[] frameArray = executionContextFromTLS.Debugger.GetCallStack().ToArray <CallStackFrame>(); if ((frameArray.Length > 0) && Regex.IsMatch(frameArray[0].Position.Text, "GetSteppablePipeline", RegexOptions.IgnoreCase)) { InvocationInfo myInvocation = base2.Command.MyInvocation; myInvocation.InvocationName = frameArray[0].InvocationInfo.InvocationName; if (frameArray.Length > 1) { IScriptExtent position = frameArray[1].Position; if ((position != null) && (position != PositionUtilities.EmptyExtent)) { myInvocation.DisplayScriptPosition = position; } } } if ((executionContextFromTLS.CurrentCommandProcessor != null) && (executionContextFromTLS.CurrentCommandProcessor.CommandRuntime != null)) { base2.CommandRuntime.SetMergeFromRuntime(executionContextFromTLS.CurrentCommandProcessor.CommandRuntime); } } return(new SteppablePipeline(executionContextFromTLS, pipe)); }
private static CommandParameterInternal SplatEnumerableElement(object splattedArgument, IScriptExtent splatExtent) { PSObject obj2 = splattedArgument as PSObject; if (obj2 != null) { PSPropertyInfo info = obj2.Properties["<CommandParameterName>"]; object baseObject = obj2.BaseObject; if (((info != null) && (info.Value is string)) && (baseObject is string)) { return(CommandParameterInternal.CreateParameter(splatExtent, (string)info.Value, (string)baseObject)); } } return(CommandParameterInternal.CreateArgument(splatExtent, splattedArgument, false)); }
/// <summary> /// Binds the specified parameters to the native command /// </summary> /// <param name="parameters"> /// The parameters to bind. /// </param> /// <param name="outputRedirected"> /// true if minishell output is redirected. /// </param> /// <param name="hostName"> /// name of the calling host. /// </param> /// <remarks> /// For any parameters that do not have a name, they are added to the command /// line arguments for the command /// </remarks> internal Collection <CommandParameterInternal> BindParameters(Collection <CommandParameterInternal> parameters, bool outputRedirected, string hostName) { MinishellParameters seen = 0; string inputFormat = null; string outputFormat = null; for (int i = 0; i < parameters.Count; i++) { var parameter = parameters[i]; if (parameter.ParameterNameSpecified) { var parameterName = parameter.ParameterName; if (CommandParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase)) { HandleSeenParameter(ref seen, MinishellParameters.Command, CommandParameter); // Value must be specified for -Command parameter. if (i + 1 >= parameters.Count) { throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, CommandParameter, typeof(ScriptBlock), null, NativeCP.NoValueForCommandParameter, "NoValueForCommandParameter"); } i += 1; // Value of -Command parameter must be scriptblock var scriptBlockArgument = parameters[i]; var argumentValue = PSObject.Base(scriptBlockArgument.ArgumentValue); if (!scriptBlockArgument.ArgumentSpecified || !(argumentValue is ScriptBlock)) { throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, CommandParameter, typeof(ScriptBlock), argumentValue.GetType(), NativeCP.IncorrectValueForCommandParameter, "IncorrectValueForCommandParameter"); } // Replace the parameters with -EncodedCommand <base64 encoded scriptblock> parameters[i - 1] = CommandParameterInternal.CreateParameter(EncodedCommandParameter, "-" + EncodedCommandParameter, parameter.ParameterAst); string encodedScript = StringToBase64Converter.StringToBase64String(argumentValue.ToString()); parameters[i] = CommandParameterInternal.CreateArgument(encodedScript, scriptBlockArgument.ArgumentAst); } else if (InputFormatParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase)) { HandleSeenParameter(ref seen, MinishellParameters.InputFormat, InputFormatParameter); // Value for -Inputformat must be specified if (i + 1 >= parameters.Count) { throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, InputFormatParameter, typeof(string), null, NativeCP.NoValueForInputFormatParameter, "NoValueForInputFormatParameter"); } // Update the argument (partial arguments are allowed) i += 1; var inputFormatArg = parameters[i]; inputFormat = ProcessFormatParameterValue(InputFormatParameter, inputFormatArg.ArgumentValue); parameters[i - 1] = CommandParameterInternal.CreateParameter(InputFormatParameter, "-" + InputFormatParameter, parameter.ParameterAst); parameters[i] = CommandParameterInternal.CreateArgument(inputFormat, inputFormatArg.ArgumentAst); } else if (OutputFormatParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase)) { HandleSeenParameter(ref seen, MinishellParameters.OutputFormat, OutputFormatParameter); // Value for -Inputformat must be specified if (i + 1 >= parameters.Count) { throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, OutputFormatParameter, typeof(string), null, NativeCP.NoValueForOutputFormatParameter, "NoValueForInputFormatParameter"); } // Update the argument (partial arguments are allowed) i += 1; var outputFormatArg = parameters[i]; outputFormat = ProcessFormatParameterValue(OutputFormatParameter, outputFormatArg.ArgumentValue); parameters[i - 1] = CommandParameterInternal.CreateParameter(OutputFormatParameter, "-" + OutputFormatParameter, parameter.ParameterAst); parameters[i] = CommandParameterInternal.CreateArgument(outputFormat, outputFormatArg.ArgumentAst); } else if (ArgsParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase)) { HandleSeenParameter(ref seen, MinishellParameters.Arguments, ArgsParameter); // Value for -Args parameter must be specified if (i + 1 >= parameters.Count) { throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, ArgsParameter, typeof(string), null, NativeCP.NoValuesSpecifiedForArgs, "NoValuesSpecifiedForArgs"); } // Get the encoded value for -args parameter i += 1; var argsArg = parameters[i]; var encodedArgs = ConvertArgsValueToEncodedString(argsArg.ArgumentValue); parameters[i - 1] = CommandParameterInternal.CreateParameter(EncodedArgsParameter, "-" + EncodedArgsParameter, parameter.ParameterAst); // NOTE: do not pass the ArgumentAst; it will fail validation in BindParameters if there // are multiple arguments (array) but encodedArgs is an encoded string. parameters[i] = CommandParameterInternal.CreateArgument(encodedArgs); } } else { // -Command is positional parameter. Bind first scriptblock to it, others are errors. var scriptBlockArgument = parameters[i]; var argumentValue = PSObject.Base(scriptBlockArgument.ArgumentValue); if (argumentValue is ScriptBlock) { HandleSeenParameter(ref seen, MinishellParameters.Command, CommandParameter); // Replace the argument with -EncodedCommand <base64 encoded scriptblock> string encodedScript = StringToBase64Converter.StringToBase64String(argumentValue.ToString()); parameters[i] = CommandParameterInternal.CreateParameterWithArgument( parameter.ArgumentAst, EncodedCommandParameter, "-" + EncodedCommandParameter, parameter.ArgumentAst, encodedScript, spaceAfterParameter: true); } } } // Add InputFormat and OutputFormat parameter if not specified if (inputFormat == null) { // For minishell default input format is xml parameters.Add(CommandParameterInternal.CreateParameter(InputFormatParameter, "-" + InputFormatParameter)); parameters.Add(CommandParameterInternal.CreateArgument(XmlFormatValue)); inputFormat = XmlFormatValue; } if (outputFormat == null) { // If output is redirected, output format should be xml outputFormat = outputRedirected ? XmlFormatValue : TextFormatValue; parameters.Add(CommandParameterInternal.CreateParameter(OutputFormatParameter, "-" + OutputFormatParameter)); parameters.Add(CommandParameterInternal.CreateArgument(outputFormat)); } // Set the output and input format class variable InputFormat = XmlFormatValue.StartsWith(inputFormat, StringComparison.OrdinalIgnoreCase) ? NativeCommandIOFormat.Xml : NativeCommandIOFormat.Text; OutputFormat = XmlFormatValue.StartsWith(outputFormat, StringComparison.OrdinalIgnoreCase) ? NativeCommandIOFormat.Xml : NativeCommandIOFormat.Text; // Note if a minishell is invoked from a non-console host, we need to // pass -nonInteractive flag. Our console host's name is "ConsoleHost". // Correct check would be see if current host has access to console and // pass noninteractive flag if doesn't. if (string.IsNullOrEmpty(hostName) || !hostName.Equals("ConsoleHost", StringComparison.OrdinalIgnoreCase)) { NonInteractive = true; parameters.Insert(0, CommandParameterInternal.CreateParameter(NonInteractiveParameter, "-" + NonInteractiveParameter)); } ((NativeCommandParameterBinder)DefaultParameterBinder).BindParameters(parameters); Diagnostics.Assert(s_emptyReturnCollection.Count == 0, "This list shouldn't be used for anything as it's shared."); return(s_emptyReturnCollection); } // BindParameters