internal static CommandParameter FromCommandParameterInternal(CommandParameterInternal internalParameter) { if (internalParameter == null) { throw PSTraceSource.NewArgumentNullException("internalParameter"); } string name = null; if (internalParameter.ParameterNameSpecified) { name = internalParameter.ParameterText; if (internalParameter.SpaceAfterParameter) { name = name + " "; } } if (internalParameter.ParameterAndArgumentSpecified) { return new CommandParameter(name, internalParameter.ArgumentValue); } if (name != null) { return new CommandParameter(name); } return new CommandParameter(null, internalParameter.ArgumentValue); }
} // Arguments /// <summary> /// Passes the binding directly through to the parameter binder. /// It does no verification against metadata. /// </summary> /// /// <param name="argument"> /// The name and value of the variable to bind. /// </param> /// /// <param name="flags"> /// Ignored. /// </param> /// /// <returns> /// True if the parameter was successfully bound. Any error condition /// produces an exception. /// </returns> /// internal override bool BindParameter( CommandParameterInternal argument, ParameterBindingFlags flags) { Diagnostics.Assert(false, "Unreachable code"); throw new InvalidOperationException(); }
protected IScriptExtent GetParameterErrorExtent(CommandParameterInternal cpi) { IScriptExtent parameterExtent = cpi.ParameterExtent; if (parameterExtent == PositionUtilities.EmptyExtent) { parameterExtent = this.InvocationInfo.ScriptPosition; } return(parameterExtent); }
internal void ReparseUnboundArguments() { Collection <CommandParameterInternal> collection = new Collection <CommandParameterInternal>(); for (int i = 0; i < this._unboundArguments.Count; i++) { CommandParameterInternal item = this._unboundArguments[i]; if (!item.ParameterNameSpecified || item.ArgumentSpecified) { collection.Add(item); } else { string parameterName = item.ParameterName; MergedCompiledCommandParameter parameter = this._bindableParameters.GetMatchingParameter(parameterName, false, true, new System.Management.Automation.InvocationInfo(this.InvocationInfo.MyCommand, item.ParameterExtent)); if (parameter == null) { collection.Add(item); } else if (IsSwitchAndSetValue(parameterName, item, parameter.Parameter)) { collection.Add(item); } else if ((this._unboundArguments.Count - 1) > i) { CommandParameterInternal internal3 = this._unboundArguments[i + 1]; if (internal3.ParameterNameSpecified) { if ((this._bindableParameters.GetMatchingParameter(internal3.ParameterName, false, true, new System.Management.Automation.InvocationInfo(this.InvocationInfo.MyCommand, internal3.ParameterExtent)) != null) || internal3.ParameterAndArgumentSpecified) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetParameterErrorExtent(item), parameter.Parameter.Name, parameter.Parameter.Type, null, "ParameterBinderStrings", "MissingArgument", new object[0]); throw exception; } i++; item.ParameterName = parameter.Parameter.Name; item.SetArgumentValue(internal3.ArgumentExtent, internal3.ParameterText); collection.Add(item); } else { i++; item.ParameterName = parameter.Parameter.Name; item.SetArgumentValue(internal3.ArgumentExtent, internal3.ArgumentValue); collection.Add(item); } } else { ParameterBindingException exception2 = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetParameterErrorExtent(item), parameter.Parameter.Name, parameter.Parameter.Type, null, "ParameterBinderStrings", "MissingArgument", new object[0]); throw exception2; } } } this._unboundArguments = collection; }
internal static CommandParameterInternal CreateArgument(IScriptExtent extent, object value, bool splatted = false) { CommandParameterInternal internal2 = new CommandParameterInternal(); Argument argument = new Argument { extent = extent, value = value, splatted = splatted }; internal2._argument = argument; return internal2; }
internal static CommandParameterInternal CreateParameter(IScriptExtent extent, string parameterName, string parameterText) { CommandParameterInternal internal2 = new CommandParameterInternal(); Parameter parameter = new Parameter { extent = extent, parameterName = parameterName, parameterText = parameterText }; internal2._parameter = parameter; return 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)); }
internal static CommandParameterInternal CreateArgument(IScriptExtent extent, object value, bool splatted = false) { CommandParameterInternal internal2 = new CommandParameterInternal(); Argument argument = new Argument { extent = extent, value = value, splatted = splatted }; internal2._argument = argument; return(internal2); }
internal static CommandParameterInternal CreateParameter(IScriptExtent extent, string parameterName, string parameterText) { CommandParameterInternal internal2 = new CommandParameterInternal(); Parameter parameter = new Parameter { extent = extent, parameterName = parameterName, parameterText = parameterText }; internal2._parameter = parameter; return(internal2); }
private bool IsMiniShell() { for (int i = 0; i < base.arguments.Count; i++) { CommandParameterInternal internal2 = base.arguments[i]; if (!internal2.ParameterNameSpecified && (internal2.ArgumentValue is ScriptBlock)) { return(true); } } return(false); }
private static bool IsSwitchAndSetValue(string argumentName, CommandParameterInternal argument, CompiledCommandParameter matchingParameter) { bool flag = false; if (matchingParameter.Type == typeof(SwitchParameter)) { argument.ParameterName = argumentName; argument.SetArgumentValue(PositionUtilities.EmptyExtent, SwitchParameter.Present); flag = true; } return(flag); }
private bool IsMiniShell() { for (int index = 0; index < this.arguments.Count; ++index) { CommandParameterInternal parameterInternal = this.arguments[index]; if (parameterInternal.Name == null && parameterInternal.Value1 != null && parameterInternal.Value1 is ScriptBlock) { NativeCommandProcessor.tracer.WriteLine("Argument number {0} is scriptblock. Its value is {1} ", (object)index, (object)parameterInternal.Value1.ToString()); return(true); } } return(false); }
private static CommandParameterInternal GetCommandParameter(CommandParameterAst commandParameterAst, System.Management.Automation.ExecutionContext context) { ExpressionAst argument = commandParameterAst.Argument; IScriptExtent errorPosition = commandParameterAst.ErrorPosition; if (argument == null) { return(CommandParameterInternal.CreateParameter(errorPosition, commandParameterAst.ParameterName, errorPosition.Text)); } object obj2 = Compiler.GetExpressionValue(argument, context, (IList)null); bool spaceAfterParameter = (errorPosition.EndLineNumber != argument.Extent.StartLineNumber) || (errorPosition.EndColumnNumber != argument.Extent.StartColumnNumber); return(CommandParameterInternal.CreateParameterWithArgument(errorPosition, commandParameterAst.ParameterName, errorPosition.Text, argument.Extent, obj2, spaceAfterParameter)); }
/// <summary> /// Add an argument to the ArgumentList. /// We may need to construct the argument out of the parameter text and the argument /// in the case that we have a parameter that appears as "-switch:value". /// </summary> /// <param name="parameter">The parameter associated with the operation.</param> /// <param name="argument">The value used with parameter.</param> internal void AddToArgumentList(CommandParameterInternal parameter, string argument) { if (parameter.ParameterNameSpecified && parameter.ParameterText.EndsWith(":")) { if (argument != parameter.ParameterText) { _argumentList.Add(parameter.ParameterText + argument); } } else { _argumentList.Add(argument); } }
internal virtual bool BindParameter(int parameterSets, CommandParameterInternal argument, MergedCompiledCommandParameter parameter, ParameterBindingFlags flags) { bool flag = false; if (parameter.BinderAssociation == ParameterBinderAssociation.DeclaredFormalParameters) { flag = this.DefaultParameterBinder.BindParameter(argument, parameter.Parameter, flags); } if (flag && ((flags & ParameterBindingFlags.IsDefaultValue) == ParameterBindingFlags.None)) { this.UnboundParameters.Remove(parameter); this.BoundParameters.Add(parameter.Parameter.Name, parameter); } return(flag); }
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)); }
private void ValidateNullOrEmptyArgument(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, Type argumentType, object parameterValue, bool recurseIntoCollections) { if ((parameterValue == null) && (argumentType != typeof(bool?))) { if (!parameterMetadata.AllowsNullArgument) { bindingTracer.WriteLine("ERROR: Argument cannot be null", new object[0]); ParameterBindingValidationException exception = new ParameterBindingValidationException(ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, argumentType, (parameterValue == null) ? null : parameterValue.GetType(), "ParameterBinderStrings", "ParameterArgumentValidationErrorNullNotAllowed", new object[0]); throw exception; } } else if (argumentType == typeof(string)) { string str = parameterValue as string; if ((str.Length == 0) && !parameterMetadata.AllowsEmptyStringArgument) { bindingTracer.WriteLine("ERROR: Argument cannot be an empty string", new object[0]); ParameterBindingValidationException exception2 = new ParameterBindingValidationException(ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (parameterValue == null) ? null : parameterValue.GetType(), "ParameterBinderStrings", "ParameterArgumentValidationErrorEmptyStringNotAllowed", new object[0]); throw exception2; } } else if (recurseIntoCollections) { switch (parameterMetadata.CollectionTypeInformation.ParameterCollectionType) { case ParameterCollectionType.IList: case ParameterCollectionType.Array: case ParameterCollectionType.ICollectionGeneric: { IEnumerator enumerator = LanguagePrimitives.GetEnumerator(parameterValue); bool flag = true; while (ParserOps.MoveNext(null, null, enumerator)) { object obj2 = ParserOps.Current(null, enumerator); flag = false; this.ValidateNullOrEmptyArgument(parameter, parameterMetadata, parameterMetadata.CollectionTypeInformation.ElementType, obj2, false); } if (flag && !parameterMetadata.AllowsEmptyCollectionArgument) { bindingTracer.WriteLine("ERROR: Argument cannot be an empty collection", new object[0]); ParameterBindingValidationException exception3 = new ParameterBindingValidationException(ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (parameterValue == null) ? null : parameterValue.GetType(), "ParameterBinderStrings", (parameterMetadata.CollectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) ? "ParameterArgumentValidationErrorEmptyArrayNotAllowed" : "ParameterArgumentValidationErrorEmptyCollectionNotAllowed", new object[0]); throw exception3; } return; } } } }
internal virtual bool BindParameter(CommandParameterInternal argument, ParameterBindingFlags flags) { bool flag = false; MergedCompiledCommandParameter parameter = this.BindableParameters.GetMatchingParameter(argument.ParameterName, (flags & ParameterBindingFlags.ThrowOnParameterNotFound) != ParameterBindingFlags.None, true, new System.Management.Automation.InvocationInfo(this.InvocationInfo.MyCommand, argument.ParameterExtent)); if (parameter == null) { return(flag); } if (this.BoundParameters.ContainsKey(parameter.Parameter.Name)) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetParameterErrorExtent(argument), argument.ParameterName, null, null, "ParameterBinderStrings", "ParameterAlreadyBound", new object[0]); throw exception; } flags &= ~ParameterBindingFlags.DelayBindScriptBlock; return(this.BindParameter(this._currentParameterSetFlag, argument, parameter, flags)); }
internal static CommandParameterInternal CreateParameterWithArgument(IScriptExtent parameterExtent, string parameterName, string parameterText, IScriptExtent argumentExtent, object value, bool spaceAfterParameter) { CommandParameterInternal internal2 = new CommandParameterInternal(); Parameter parameter = new Parameter { extent = parameterExtent, parameterName = parameterName, parameterText = parameterText }; internal2._parameter = parameter; Argument argument = new Argument { extent = argumentExtent, value = value }; internal2._argument = argument; internal2._spaceAfterParameter = spaceAfterParameter; return internal2; }
internal static CommandProcessorBase CreateGetHelpCommandProcessor(ExecutionContext context, string helpTarget, HelpCategory helpCategory) { if (context == null) { throw PSTraceSource.NewArgumentNullException("context"); } if (string.IsNullOrEmpty(helpTarget)) { throw PSTraceSource.NewArgumentNullException("helpTarget"); } CommandProcessorBase base2 = context.CreateCommand("get-help", false); CommandParameterInternal parameter = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, "Name", "-Name:", PositionUtilities.EmptyExtent, helpTarget, false); base2.AddParameter(parameter); parameter = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, "Category", "-Category:", PositionUtilities.EmptyExtent, helpCategory.ToString(), false); base2.AddParameter(parameter); return(base2); }
private bool ShouldContinueUncoercedBind(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, ParameterBindingFlags flags, ref object parameterValue) { bool flag = false; Type c = parameterMetadata.Type; if (parameterValue == null) { return(((c == null) || ((flags & ParameterBindingFlags.IsDefaultValue) != ParameterBindingFlags.None)) || (!c.IsValueType && (c != typeof(string)))); } Type type = parameterValue.GetType(); if (type == c) { return(true); } if (type.IsSubclassOf(c)) { return(true); } if (c.IsAssignableFrom(type)) { return(true); } if ((parameterValue is PSObject) && !((PSObject)parameterValue).immediateBaseObjectIsEmpty) { parameterValue = ((PSObject)parameterValue).BaseObject; type = parameterValue.GetType(); if (((type == c) || type.IsSubclassOf(c)) || c.IsAssignableFrom(type)) { return(true); } } if (parameterMetadata.CollectionTypeInformation.ParameterCollectionType != ParameterCollectionType.NotCollection) { bool coercionRequired = false; object obj2 = this.EncodeCollection(parameter, parameterMetadata.Name, parameterMetadata.CollectionTypeInformation, c, parameterValue, false, out coercionRequired); if ((obj2 != null) && !coercionRequired) { parameterValue = obj2; flag = true; } } return(flag); }
internal static CommandParameterInternal CreateParameterWithArgument(IScriptExtent parameterExtent, string parameterName, string parameterText, IScriptExtent argumentExtent, object value, bool spaceAfterParameter) { CommandParameterInternal internal2 = new CommandParameterInternal(); Parameter parameter = new Parameter { extent = parameterExtent, parameterName = parameterName, parameterText = parameterText }; internal2._parameter = parameter; Argument argument = new Argument { extent = argumentExtent, value = value }; internal2._argument = argument; internal2._spaceAfterParameter = spaceAfterParameter; return(internal2); }
private static CommandParameterInternal GetNextPositionalArgument(List <CommandParameterInternal> unboundArgumentsCollection, Collection <CommandParameterInternal> nonPositionalArguments, ref int unboundArgumentsIndex) { while (unboundArgumentsIndex < unboundArgumentsCollection.Count) { CommandParameterInternal item = unboundArgumentsCollection[unboundArgumentsIndex++]; if (!item.ParameterNameSpecified) { return(item); } nonPositionalArguments.Add(item); if ((unboundArgumentsCollection.Count - 1) >= unboundArgumentsIndex) { item = unboundArgumentsCollection[unboundArgumentsIndex]; if (!item.ParameterNameSpecified) { nonPositionalArguments.Add(item); unboundArgumentsIndex++; } } } return(null); }
private object HandleNullParameterForSpecialTypes(CommandParameterInternal argument, string parameterName, Type toType, object currentValue) { if (toType == typeof(bool)) { bindingTracer.WriteLine("ERROR: No argument is specified for parameter and parameter type is BOOL", new object[0]); ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, null, "ParameterBinderStrings", "ParameterArgumentValidationErrorNullNotAllowed", new object[] { "" }); throw exception; } if (toType == typeof(SwitchParameter)) { bindingTracer.WriteLine("Arg is null or not present, parameter type is SWITCHPARAMTER, value is true.", new object[0]); return(SwitchParameter.Present); } if (currentValue == UnboundParameter.Value) { bindingTracer.TraceError("ERROR: No argument was specified for the parameter and the parameter is not of type bool", new object[0]); ParameterBindingException exception2 = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetParameterErrorExtent(argument), parameterName, toType, null, "ParameterBinderStrings", "MissingArgument", new object[0]); throw exception2; } bindingTracer.WriteLine("Arg is null, parameter type not bool or SwitchParameter, value is null.", new object[0]); return(null); }
internal Pipe GetRedirectionPipe(ExecutionContext context, System.Management.Automation.Internal.PipelineProcessor parentPipelineProcessor) { if (string.IsNullOrWhiteSpace(this.File)) { return(new Pipe { NullPipe = true }); } CommandProcessorBase commandProcessor = context.CreateCommand("out-file", false); CommandParameterInternal parameter = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, "Encoding", "-Encoding:", PositionUtilities.EmptyExtent, "Unicode", false); commandProcessor.AddParameter(parameter); if (this.Appending) { parameter = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, "Append", "-Append:", PositionUtilities.EmptyExtent, true, false); commandProcessor.AddParameter(parameter); } parameter = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, "Filepath", "-Filepath:", PositionUtilities.EmptyExtent, this.File, false); commandProcessor.AddParameter(parameter); this.PipelineProcessor = new System.Management.Automation.Internal.PipelineProcessor(); this.PipelineProcessor.Add(commandProcessor); try { this.PipelineProcessor.StartStepping(true); } catch (RuntimeException exception) { if (exception.ErrorRecord.Exception is ArgumentException) { throw InterpreterError.NewInterpreterExceptionWithInnerException(null, typeof(RuntimeException), null, "RedirectionFailed", ParserStrings.RedirectionFailed, exception.ErrorRecord.Exception, new object[] { this.File, exception.ErrorRecord.Exception.Message }); } throw; } if (parentPipelineProcessor != null) { parentPipelineProcessor.AddRedirectionPipe(this.PipelineProcessor); } return(new Pipe(context, this.PipelineProcessor)); }
private void ValidatePSTypeName(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, bool retryOtherBindingAfterFailure, object parameterValue) { if (parameterValue != null) { IEnumerable <string> internalTypeNames = PSObject.AsPSObject(parameterValue).InternalTypeNames; string pSTypeName = parameterMetadata.PSTypeName; if (!internalTypeNames.Contains <string>(pSTypeName, StringComparer.OrdinalIgnoreCase)) { ParameterBindingException exception2; object[] arguments = new object[] { ((this.invocationInfo != null) && (this.invocationInfo.MyCommand != null)) ? this.invocationInfo.MyCommand.Name : string.Empty, parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), 0, 0, pSTypeName }; PSInvalidCastException innerException = new PSInvalidCastException(ErrorCategory.InvalidArgument.ToString(), null, ResourceManagerCache.GetResourceString("ParameterBinderStrings", "MismatchedPSTypeName"), arguments); if (!retryOtherBindingAfterFailure) { exception2 = new ParameterBindingArgumentTransformationException(innerException, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), "ParameterBinderStrings", "MismatchedPSTypeName", new object[] { pSTypeName }); } else { exception2 = new ParameterBindingException(innerException, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), "ParameterBinderStrings", "MismatchedPSTypeName", new object[] { pSTypeName }); } throw exception2; } } }
/// <summary> /// Add an argument to the ArgumentList. /// We may need to construct the argument out of the parameter text and the argument /// in the case that we have a parameter that appears as "-switch:value". /// </summary> /// <param name="parameter">The parameter associated with the operation.</param> /// <param name="argument">The value used with parameter.</param> internal void AddToArgumentList(CommandParameterInternal parameter, string argument) { if (parameter.ParameterNameSpecified && parameter.ParameterText.EndsWith(":")) { if (argument != parameter.ParameterText) { // Only combine the text and argument if there was no space after the parameter, // otherwise, add the parameter and arguments as separate elements. if (parameter.SpaceAfterParameter) { _argumentList.Add(parameter.ParameterText); _argumentList.Add(argument); } else { _argumentList.Add(parameter.ParameterText + argument); } } } else { _argumentList.Add(argument); } }
internal static void InvokePipeline (object input, bool ignoreInput, CommandParameterInternal[][] pipeElements, CommandBaseAst[] pipeElementAsts, CommandRedirection[][] commandRedirections, FunctionContext funcContext) { PipelineProcessor pipelineProcessor = new PipelineProcessor (); System.Management.Automation.ExecutionContext context = funcContext._executionContext; Pipe pipe = funcContext._outputPipe; try { if (context.Events != null) { context.Events.ProcessPendingActions (); } if ((input == AutomationNull.Value) && !ignoreInput) { AddNoopCommandProcessor (pipelineProcessor, context); } CommandProcessorBase commandProcessor = null; CommandRedirection[] redirections = null; for (int i = 0; i < pipeElements.Length; i++) { redirections = (commandRedirections != null) ? commandRedirections [i] : null; commandProcessor = AddCommand (pipelineProcessor, pipeElements [i], pipeElementAsts [i], redirections, context); } if ((commandProcessor != null) && !commandProcessor.CommandRuntime.OutputPipe.IsRedirected) { pipelineProcessor.LinkPipelineSuccessOutput (pipe ?? new Pipe (new ArrayList ())); if (redirections != null) { foreach (CommandRedirection redirection in redirections) { if (redirection is MergingRedirection) { redirection.Bind (pipelineProcessor, commandProcessor, context); } } } } context.PushPipelineProcessor (pipelineProcessor); try { pipelineProcessor.SynchronousExecuteEnumerate (input, null, true); } finally { context.PopPipelineProcessor (false); } } finally { context.QuestionMarkVariableValue = !pipelineProcessor.ExecutionFailed; pipelineProcessor.Dispose(); } }
internal override bool BindParameter(CommandParameterInternal argument, ParameterBindingFlags flags) { base.DefaultParameterBinder.BindParameter(argument.ParameterName, argument.ArgumentValue); return true; }
/// <summary> /// On Windows, just append <paramref name="arg"/>. /// On Unix, do globbing as appropriate, otherwise just append <paramref name="arg"/>. /// </summary> /// <param name="arg">The argument that possibly needs expansion.</param> /// <param name="parameter">The parameter associated with the operation.</param> /// <param name="usedQuotes">True if the argument was a quoted string (single or double).</param> private void PossiblyGlobArg(string arg, CommandParameterInternal parameter, bool usedQuotes) { var argExpanded = false; #if UNIX // On UNIX systems, we expand arguments containing wildcard expressions against // the file system just like bash, etc. if (!usedQuotes && WildcardPattern.ContainsWildcardCharacters(arg)) { // See if the current working directory is a filesystem provider location // We won't do the expansion if it isn't since native commands can only access the file system. var cwdinfo = Context.EngineSessionState.CurrentLocation; // If it's a filesystem location then expand the wildcards if (cwdinfo.Provider.Name.Equals(FileSystemProvider.ProviderName, StringComparison.OrdinalIgnoreCase)) { // On UNIX, paths starting with ~ or absolute paths are not normalized bool normalizePath = arg.Length == 0 || !(arg[0] == '~' || arg[0] == '/'); // See if there are any matching paths otherwise just add the pattern as the argument Collection <PSObject> paths = null; try { paths = Context.EngineSessionState.InvokeProvider.ChildItem.Get(arg, false); } catch { // Fallthrough will append the pattern unchanged. } // Expand paths, but only from the file system. if (paths?.Count > 0 && paths.All(p => p.BaseObject is FileSystemInfo)) { var sep = string.Empty; foreach (var path in paths) { _arguments.Append(sep); sep = " "; var expandedPath = (path.BaseObject as FileSystemInfo).FullName; if (normalizePath) { expandedPath = Context.SessionState.Path.NormalizeRelativePath(expandedPath, cwdinfo.ProviderPath); } // If the path contains spaces, then add quotes around it. if (NeedQuotes(expandedPath)) { _arguments.Append('"'); _arguments.Append(expandedPath); _arguments.Append('"'); } else { _arguments.Append(expandedPath); } AddToArgumentList(parameter, expandedPath); argExpanded = true; } } } } else if (!usedQuotes) { // Even if there are no wildcards, we still need to possibly // expand ~ into the filesystem provider home directory path ProviderInfo fileSystemProvider = Context.EngineSessionState.GetSingleProvider(FileSystemProvider.ProviderName); string home = fileSystemProvider.Home; if (string.Equals(arg, "~")) { _arguments.Append(home); AddToArgumentList(parameter, home); argExpanded = true; } else if (arg.StartsWith("~/", StringComparison.OrdinalIgnoreCase)) { var replacementString = string.Concat(home, arg.AsSpan(1)); _arguments.Append(replacementString); AddToArgumentList(parameter, replacementString); argExpanded = true; } } #endif // UNIX if (!argExpanded) { _arguments.Append(arg); AddToArgumentList(parameter, arg); } }
/// <summary> /// Adds an unbound parameter. /// </summary> /// <param name="parameter"> /// The parameter to add to the unbound arguments list /// </param> internal void AddParameter(CommandParameterInternal parameter) { Diagnostics.Assert(parameter != null, "Caller to verify parameter argument"); arguments.Add(parameter); } // AddParameter
/// <summary> /// Binds the specified argument to the specified parameter using the appropriate /// parameter binder. /// </summary> /// /// <param name="argument"> /// The argument to be bound. /// </param> /// /// <param name="parameter"> /// The metadata for the parameter to bind the argument to. /// </param> /// /// <param name="flags"> /// Flags for type coercion and validation. /// </param> /// /// <returns> /// True if the parameter was successfully bound. False if <paramref name="flags"/> /// has the flag <see cref="ParameterBindingFlags.ShouldCoerceType"/> set and the type does not match the parameter type. /// </returns> /// private bool BindParameter( CommandParameterInternal argument, MergedCompiledCommandParameter parameter, ParameterBindingFlags flags) { bool result = false; switch (parameter.BinderAssociation) { case ParameterBinderAssociation.DeclaredFormalParameters: result = DefaultParameterBinder.BindParameter( argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.CommonParameters: result = CommonParametersBinder.BindParameter( argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.ShouldProcessParameters: Diagnostics.Assert( _commandMetadata.SupportsShouldProcess, "The metadata for the ShouldProcessParameters should only be available if the command supports ShouldProcess"); result = ShouldProcessParametersBinder.BindParameter( argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.PagingParameters: Diagnostics.Assert( _commandMetadata.SupportsPaging, "The metadata for the PagingParameters should only be available if the command supports paging"); result = PagingParametersBinder.BindParameter( argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.TransactionParameters: Diagnostics.Assert( _commandMetadata.SupportsTransactions, "The metadata for the TransactionsParameters should only be available if the command supports transactions"); result = TransactionParametersBinder.BindParameter( argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.DynamicParameters: Diagnostics.Assert( _commandMetadata.ImplementsDynamicParameters, "The metadata for the dynamic parameters should only be available if the command supports IDynamicParameters"); if (_dynamicParameterBinder != null) { result = _dynamicParameterBinder.BindParameter( argument, parameter.Parameter, flags); } break; } if (result && ((flags & ParameterBindingFlags.IsDefaultValue) == 0)) { // Update the current valid parameter set flags if (parameter.Parameter.ParameterSetFlags != 0) { _currentParameterSetFlag &= parameter.Parameter.ParameterSetFlags; } UnboundParameters.Remove(parameter); if (!BoundParameters.ContainsKey(parameter.Parameter.Name)) { BoundParameters.Add(parameter.Parameter.Name, parameter); } if (!BoundArguments.ContainsKey(parameter.Parameter.Name)) { BoundArguments.Add(parameter.Parameter.Name, argument); } if (parameter.Parameter.ObsoleteAttribute != null && (flags & ParameterBindingFlags.IsDefaultValue) == 0 && !BoundObsoleteParameterNames.Contains(parameter.Parameter.Name)) { string obsoleteWarning = String.Format( CultureInfo.InvariantCulture, ParameterBinderStrings.UseOfDeprecatedParameterWarning, parameter.Parameter.Name, parameter.Parameter.ObsoleteAttribute.Message); var warningRecord = new WarningRecord(ParameterBinderBase.FQIDParameterObsolete, obsoleteWarning); BoundObsoleteParameterNames.Add(parameter.Parameter.Name); if (ObsoleteParameterWarningList == null) ObsoleteParameterWarningList = new List<WarningRecord>(); ObsoleteParameterWarningList.Add(warningRecord); } } return result; }
/// <summary> /// Restores the specified parameter to the original value. /// </summary> /// /// <param name="argumentToBind"> /// The argument containing the value to restore. /// </param> /// /// <param name="parameter"> /// The metadata for the parameter to restore. /// </param> /// /// <returns> /// True if the parameter was restored correctly, or false otherwise. /// </returns> /// private bool RestoreParameter(CommandParameterInternal argumentToBind, MergedCompiledCommandParameter parameter) { switch (parameter.BinderAssociation) { case ParameterBinderAssociation.DeclaredFormalParameters: DefaultParameterBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue, parameter.Parameter); break; case ParameterBinderAssociation.CommonParameters: CommonParametersBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue, parameter.Parameter); break; case ParameterBinderAssociation.ShouldProcessParameters: Diagnostics.Assert( _commandMetadata.SupportsShouldProcess, "The metadata for the ShouldProcessParameters should only be available if the command supports ShouldProcess"); ShouldProcessParametersBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue, parameter.Parameter); break; case ParameterBinderAssociation.PagingParameters: Diagnostics.Assert( _commandMetadata.SupportsPaging, "The metadata for the PagingParameters should only be available if the command supports paging"); PagingParametersBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue, parameter.Parameter); break; case ParameterBinderAssociation.TransactionParameters: Diagnostics.Assert( _commandMetadata.SupportsTransactions, "The metadata for the TransactionParameters should only be available if the command supports Transactions"); TransactionParametersBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue, parameter.Parameter); break; case ParameterBinderAssociation.DynamicParameters: Diagnostics.Assert( _commandMetadata.ImplementsDynamicParameters, "The metadata for the dynamic parameters should only be available if the command supports IDynamicParameters"); if (_dynamicParameterBinder != null) { _dynamicParameterBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue, parameter.Parameter); } break; } return true; }
private bool BindParameter(CommandParameterInternal argument, MergedCompiledCommandParameter parameter, ParameterBindingFlags flags) { bool flag = false; switch (parameter.BinderAssociation) { case ParameterBinderAssociation.DeclaredFormalParameters: flag = base.DefaultParameterBinder.BindParameter(argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.DynamicParameters: if (this._dynamicParameterBinder != null) { flag = this._dynamicParameterBinder.BindParameter(argument, parameter.Parameter, flags); } break; case ParameterBinderAssociation.CommonParameters: flag = this.CommonParametersBinder.BindParameter(argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.ShouldProcessParameters: flag = this.ShouldProcessParametersBinder.BindParameter(argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.TransactionParameters: flag = this.TransactionParametersBinder.BindParameter(argument, parameter.Parameter, flags); break; case ParameterBinderAssociation.PagingParameters: flag = this.PagingParametersBinder.BindParameter(argument, parameter.Parameter, flags); break; } if (flag && ((flags & ParameterBindingFlags.IsDefaultValue) == ParameterBindingFlags.None)) { if (parameter.Parameter.ParameterSetFlags != 0) { base._currentParameterSetFlag &= parameter.Parameter.ParameterSetFlags; } base.UnboundParameters.Remove(parameter); if (!base.BoundParameters.ContainsKey(parameter.Parameter.Name)) { base.BoundParameters.Add(parameter.Parameter.Name, parameter); } if (!base.BoundArguments.ContainsKey(parameter.Parameter.Name)) { base.BoundArguments.Add(parameter.Parameter.Name, argument); } } return flag; }
private bool ShouldContinueUncoercedBind(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, ParameterBindingFlags flags, ref object parameterValue) { bool flag = false; Type c = parameterMetadata.Type; if (parameterValue == null) { return (((c == null) || ((flags & ParameterBindingFlags.IsDefaultValue) != ParameterBindingFlags.None)) || (!c.IsValueType && (c != typeof(string)))); } Type type = parameterValue.GetType(); if (type == c) { return true; } if (type.IsSubclassOf(c)) { return true; } if (c.IsAssignableFrom(type)) { return true; } if ((parameterValue is PSObject) && !((PSObject) parameterValue).immediateBaseObjectIsEmpty) { parameterValue = ((PSObject) parameterValue).BaseObject; type = parameterValue.GetType(); if (((type == c) || type.IsSubclassOf(c)) || c.IsAssignableFrom(type)) { return true; } } if (parameterMetadata.CollectionTypeInformation.ParameterCollectionType != ParameterCollectionType.NotCollection) { bool coercionRequired = false; object obj2 = this.EncodeCollection(parameter, parameterMetadata.Name, parameterMetadata.CollectionTypeInformation, c, parameterValue, false, out coercionRequired); if ((obj2 != null) && !coercionRequired) { parameterValue = obj2; flag = true; } } return flag; }
private object HandleNullParameterForSpecialTypes(CommandParameterInternal argument, string parameterName, Type toType, object currentValue) { if (toType == typeof(bool)) { bindingTracer.WriteLine("ERROR: No argument is specified for parameter and parameter type is BOOL", new object[0]); ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, null, "ParameterBinderStrings", "ParameterArgumentValidationErrorNullNotAllowed", new object[] { "" }); throw exception; } if (toType == typeof(SwitchParameter)) { bindingTracer.WriteLine("Arg is null or not present, parameter type is SWITCHPARAMTER, value is true.", new object[0]); return SwitchParameter.Present; } if (currentValue == UnboundParameter.Value) { bindingTracer.TraceError("ERROR: No argument was specified for the parameter and the parameter is not of type bool", new object[0]); ParameterBindingException exception2 = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetParameterErrorExtent(argument), parameterName, toType, null, "ParameterBinderStrings", "MissingArgument", new object[0]); throw exception2; } bindingTracer.WriteLine("Arg is null, parameter type not bool or SwitchParameter, value is null.", new object[0]); return null; }
protected IScriptExtent GetParameterErrorExtent(CommandParameterInternal cpi) { IScriptExtent parameterExtent = cpi.ParameterExtent; if (parameterExtent == PositionUtilities.EmptyExtent) { parameterExtent = this.InvocationInfo.ScriptPosition; } return parameterExtent; }
private static CommandProcessorBase AddCommand(PipelineProcessor pipe, CommandParameterInternal[] commandElements, CommandBaseAst commandBaseAst, CommandRedirection[] redirections, System.Management.Automation.ExecutionContext context) { object parameterText; IScriptExtent parameterExtent; CommandProcessorBase base2; InternalCommand command; string str3; HelpCategory category; CommandAst ast = commandBaseAst as CommandAst; TokenKind kind = (ast != null) ? ast.InvocationOperator : TokenKind.Unknown; bool dotSource = kind == TokenKind.Dot; SessionStateInternal sessionState = null; int index = 0; PSModuleInfo info = PSObject.Base(commandElements[0].ArgumentValue) as PSModuleInfo; if (info != null) { if ((info.ModuleType == ModuleType.Binary) && (info.SessionState == null)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "CantInvokeInBinaryModule", ParserStrings.CantInvokeInBinaryModule, new object[] { info.Name }); } if (info.SessionState == null) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "CantInvokeInNonImportedModule", ParserStrings.CantInvokeInNonImportedModule, new object[] { info.Name }); } sessionState = info.SessionState.Internal; index++; } CommandParameterInternal internal3 = commandElements[index]; if (internal3.ParameterNameSpecified) { parameterText = internal3.ParameterText; parameterExtent = internal3.ParameterExtent; if (!internal3.ArgumentSpecified) { } } else { parameterText = PSObject.Base(internal3.ArgumentValue); parameterExtent = internal3.ArgumentExtent; } string str = dotSource ? "." : ((kind == TokenKind.Ampersand) ? "&" : null); ScriptBlock scriptblock = parameterText as ScriptBlock; if (scriptblock != null) { base2 = CommandDiscovery.CreateCommandProcessorForScript(scriptblock, context, !dotSource, sessionState); } else { CommandInfo commandInfo = parameterText as CommandInfo; if (commandInfo != null) { base2 = context.CommandDiscovery.LookupCommandProcessor(commandInfo, context.EngineSessionState.CurrentScope.ScopeOrigin, new bool?(!dotSource), sessionState); } else { string str2 = (parameterText as string) ?? PSObject.ToStringParser(context, parameterText); str = str ?? str2; if (string.IsNullOrEmpty(str2)) { throw InterpreterError.NewInterpreterException(parameterText, typeof(RuntimeException), parameterExtent, "BadExpression", ParserStrings.BadExpression, new object[] { dotSource ? "." : "&" }); } try { if (sessionState != null) { SessionStateInternal engineSessionState = context.EngineSessionState; try { context.EngineSessionState = sessionState; base2 = context.CreateCommand(str2, dotSource); goto Label_025D; } finally { context.EngineSessionState = engineSessionState; } } base2 = context.CreateCommand(str2, dotSource); } catch (RuntimeException exception) { if (exception.ErrorRecord.InvocationInfo == null) { InvocationInfo invocationInfo = new InvocationInfo(null, parameterExtent, context) { InvocationName = str }; exception.ErrorRecord.SetInvocationInfo(invocationInfo); } throw; } } } Label_025D: command = base2.Command; base2.UseLocalScope = !dotSource && ((command is ScriptCommand) || (command is PSScriptCmdlet)); bool flag2 = base2 is NativeCommandProcessor; for (int i = index + 1; i < commandElements.Length; i++) { CommandParameterInternal parameter = commandElements[i]; if ((!parameter.ParameterNameSpecified || !parameter.ParameterName.Equals("-", StringComparison.OrdinalIgnoreCase)) || flag2) { if (parameter.ArgumentSplatted) { foreach (CommandParameterInternal internal6 in Splat(parameter.ArgumentValue, parameter.ArgumentExtent)) { base2.AddParameter(internal6); } } else { base2.AddParameter(parameter); } } } if (base2.IsHelpRequested(out str3, out category)) { base2 = CommandProcessorBase.CreateGetHelpCommandProcessor(context, str3, category); } base2.Command.InvocationExtent = commandBaseAst.Extent; base2.Command.MyInvocation.ScriptPosition = commandBaseAst.Extent; base2.Command.MyInvocation.InvocationName = str; pipe.Add(base2); bool flag3 = false; bool flag4 = false; bool flag5 = false; bool flag6 = false; if (redirections != null) { foreach (CommandRedirection redirection in redirections) { redirection.Bind(pipe, base2, context); switch (redirection.FromStream) { case RedirectionStream.All: flag3 = true; flag4 = true; flag5 = true; flag6 = true; break; case RedirectionStream.Error: flag3 = true; break; case RedirectionStream.Warning: flag4 = true; break; case RedirectionStream.Verbose: flag5 = true; break; case RedirectionStream.Debug: flag6 = true; break; } } } if (!flag3) { if (context.ShellFunctionErrorOutputPipe != null) { base2.CommandRuntime.ErrorOutputPipe = context.ShellFunctionErrorOutputPipe; } else { base2.CommandRuntime.ErrorOutputPipe.ExternalWriter = context.ExternalErrorOutput; } } if (!flag4 && (context.ExpressionWarningOutputPipe != null)) { base2.CommandRuntime.WarningOutputPipe = context.ExpressionWarningOutputPipe; flag4 = true; } if (!flag5 && (context.ExpressionVerboseOutputPipe != null)) { base2.CommandRuntime.VerboseOutputPipe = context.ExpressionVerboseOutputPipe; flag5 = true; } if (!flag6 && (context.ExpressionDebugOutputPipe != null)) { base2.CommandRuntime.DebugOutputPipe = context.ExpressionDebugOutputPipe; flag6 = true; } if ((context.CurrentCommandProcessor != null) && (context.CurrentCommandProcessor.CommandRuntime != null)) { if (!flag4 && (context.CurrentCommandProcessor.CommandRuntime.WarningOutputPipe != null)) { base2.CommandRuntime.WarningOutputPipe = context.CurrentCommandProcessor.CommandRuntime.WarningOutputPipe; } if (!flag5 && (context.CurrentCommandProcessor.CommandRuntime.VerboseOutputPipe != null)) { base2.CommandRuntime.VerboseOutputPipe = context.CurrentCommandProcessor.CommandRuntime.VerboseOutputPipe; } if (!flag6 && (context.CurrentCommandProcessor.CommandRuntime.DebugOutputPipe != null)) { base2.CommandRuntime.DebugOutputPipe = context.CurrentCommandProcessor.CommandRuntime.DebugOutputPipe; } } return base2; }
/// <summary> /// Stringize a non-IEnum argument to a native command, adding quotes /// and trailing spaces as appropriate. An array gets added as multiple arguments /// each of which will be stringized. /// </summary> /// <param name="context">Execution context instance.</param> /// <param name="parameter">The parameter associated with the operation.</param> /// <param name="obj">The object to append.</param> /// <param name="argArrayAst">If the argument was an array literal, the Ast, otherwise null.</param> /// <param name="sawVerbatimArgumentMarker">True if the argument occurs after --%.</param> /// <param name="stringConstantType">Bare, SingleQuoted, or DoubleQuoted.</param> private void AppendOneNativeArgument(ExecutionContext context, CommandParameterInternal parameter, object obj, ArrayLiteralAst argArrayAst, bool sawVerbatimArgumentMarker, StringConstantType stringConstantType) { IEnumerator list = LanguagePrimitives.GetEnumerator(obj); Diagnostics.Assert((argArrayAst == null) || (obj is object[] && ((object[])obj).Length == argArrayAst.Elements.Count), "array argument and ArrayLiteralAst differ in number of elements"); int currentElement = -1; string separator = string.Empty; do { string arg; object currentObj; if (list == null) { arg = PSObject.ToStringParser(context, obj); currentObj = obj; } else { if (!ParserOps.MoveNext(context, null, list)) { break; } currentObj = ParserOps.Current(null, list); arg = PSObject.ToStringParser(context, currentObj); currentElement += 1; if (currentElement != 0) { separator = GetEnumerableArgSeparator(argArrayAst, currentElement); } } if (!string.IsNullOrEmpty(arg)) { // Only add the separator to the argument string rather than adding a separator to the ArgumentList. _arguments.Append(separator); if (sawVerbatimArgumentMarker) { arg = Environment.ExpandEnvironmentVariables(arg); _arguments.Append(arg); // we need to split the argument on spaces _argumentList.AddRange(arg.Split(' ', StringSplitOptions.RemoveEmptyEntries)); } else { // We need to add quotes if the argument has unquoted spaces. The // quotes could appear anywhere inside the string, not just at the start, // e.g. // $a = 'a"b c"d' // echoargs $a 'a"b c"d' a"b c"d // // The above should see 3 identical arguments in argv (the command line will // actually have quotes in different places, but the Win32 command line=>argv parser // erases those differences. // // We need to check quotes that the win32 argument parser checks which is currently // just the normal double quotes, no other special quotes. Also note that mismatched // quotes are supported if (NeedQuotes(arg)) { _arguments.Append('"'); if (stringConstantType == StringConstantType.DoubleQuoted) { _arguments.Append(ResolvePath(arg, Context)); AddToArgumentList(parameter, ResolvePath(arg, Context)); } else { _arguments.Append(arg); AddToArgumentList(parameter, arg); } // need to escape all trailing backslashes so the native command receives it correctly // according to http://www.daviddeley.com/autohotkey/parameters/parameters.htm#WINCRULESDOC for (int i = arg.Length - 1; i >= 0 && arg[i] == '\\'; i--) { _arguments.Append('\\'); } _arguments.Append('"'); } else { if (argArrayAst != null && UseArgumentList) { // We have a literal array, so take the extent, break it on spaces and add them to the argument list. foreach (string element in argArrayAst.Extent.Text.Split(' ', StringSplitOptions.RemoveEmptyEntries)) { PossiblyGlobArg(element, parameter, stringConstantType); } break; } else { PossiblyGlobArg(arg, parameter, stringConstantType); } } } } else if (UseArgumentList && currentObj != null) { // add empty strings to arglist, but not nulls AddToArgumentList(parameter, arg); } }while (list != null); }
private object CoerceTypeAsNeeded(CommandParameterInternal argument, string parameterName, Type toType, ParameterCollectionTypeInformation collectionTypeInfo, object currentValue) { if (argument == null) { throw PSTraceSource.NewArgumentNullException("argument"); } if (toType == null) { throw PSTraceSource.NewArgumentNullException("toType"); } if (collectionTypeInfo == null) { collectionTypeInfo = new ParameterCollectionTypeInformation(toType); } object result = currentValue; using (bindingTracer.TraceScope("COERCE arg to [{0}]", new object[] { toType })) { Type c = null; try { if (IsNullParameterValue(currentValue)) { return this.HandleNullParameterForSpecialTypes(argument, parameterName, toType, currentValue); } c = currentValue.GetType(); if (toType.IsAssignableFrom(c)) { bindingTracer.WriteLine("Parameter and arg types the same, no coercion is needed.", new object[0]); return currentValue; } bindingTracer.WriteLine("Trying to convert argument value from {0} to {1}", new object[] { c, toType }); if (toType == typeof(PSObject)) { if ((this.command != null) && (currentValue == this.command.CurrentPipelineObject.BaseObject)) { currentValue = this.command.CurrentPipelineObject; } bindingTracer.WriteLine("The parameter is of type [{0}] and the argument is an PSObject, so the parameter value is the argument value wrapped into an PSObject.", new object[] { toType }); return LanguagePrimitives.AsPSObjectOrNull(currentValue); } if ((toType == typeof(string)) && (c == typeof(PSObject))) { PSObject obj3 = (PSObject) currentValue; if (obj3 == AutomationNull.Value) { bindingTracer.WriteLine("CONVERT a null PSObject to a null string.", new object[0]); return null; } } if (((toType == typeof(bool)) || (toType == typeof(SwitchParameter))) || (toType == typeof(bool?))) { Type type = null; if (c == typeof(PSObject)) { PSObject obj4 = (PSObject) currentValue; currentValue = obj4.BaseObject; if (currentValue is SwitchParameter) { SwitchParameter parameter = (SwitchParameter) currentValue; currentValue = parameter.IsPresent; } type = currentValue.GetType(); } else { type = c; } if (type == typeof(bool)) { if (LanguagePrimitives.IsBooleanType(toType)) { return ParserOps.BoolToObject((bool) currentValue); } return new SwitchParameter((bool) currentValue); } if (type == typeof(int)) { if (((int) LanguagePrimitives.ConvertTo(currentValue, typeof(int), CultureInfo.InvariantCulture)) != 0) { if (LanguagePrimitives.IsBooleanType(toType)) { return ParserOps.BoolToObject(true); } return new SwitchParameter(true); } if (LanguagePrimitives.IsBooleanType(toType)) { return ParserOps.BoolToObject(false); } return new SwitchParameter(false); } if (LanguagePrimitives.IsNumeric(Type.GetTypeCode(type))) { double num = (double) LanguagePrimitives.ConvertTo(currentValue, typeof(double), CultureInfo.InvariantCulture); if (num == 0.0) { if (LanguagePrimitives.IsBooleanType(toType)) { return ParserOps.BoolToObject(false); } return new SwitchParameter(false); } if (LanguagePrimitives.IsBooleanType(toType)) { return ParserOps.BoolToObject(true); } return new SwitchParameter(true); } ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgument", new object[] { type, "" }); throw exception; } if ((collectionTypeInfo.ParameterCollectionType == ParameterCollectionType.ICollectionGeneric) || (collectionTypeInfo.ParameterCollectionType == ParameterCollectionType.IList)) { object obj5 = PSObject.Base(currentValue); if (obj5 != null) { ConversionRank conversionRank = LanguagePrimitives.GetConversionRank(obj5.GetType(), toType); if ((((conversionRank == ConversionRank.Constructor) || (conversionRank == ConversionRank.ImplicitCast)) || (conversionRank == ConversionRank.ExplicitCast)) && LanguagePrimitives.TryConvertTo(currentValue, toType, Thread.CurrentThread.CurrentCulture, out result)) { return result; } } } if (collectionTypeInfo.ParameterCollectionType != ParameterCollectionType.NotCollection) { bindingTracer.WriteLine("ENCODING arg into collection", new object[0]); bool coercionRequired = false; return this.EncodeCollection(argument, parameterName, collectionTypeInfo, toType, currentValue, collectionTypeInfo.ElementType != null, out coercionRequired); } if (((((GetIList(currentValue) != null) && (toType != typeof(object))) && ((toType != typeof(PSObject)) && (toType != typeof(PSListModifier)))) && ((!toType.IsGenericType || (toType.GetGenericTypeDefinition() != typeof(PSListModifier<>))) && (!toType.IsGenericType || (toType.GetGenericTypeDefinition() != typeof(FlagsExpression<>))))) && !toType.IsEnum) { throw new NotSupportedException(); } bindingTracer.WriteLine("CONVERT arg type to param type using LanguagePrimitives.ConvertTo", new object[0]); bool flag2 = false; if (this.context.LanguageMode == PSLanguageMode.ConstrainedLanguage) { object obj6 = PSObject.Base(currentValue); bool flag3 = obj6 is PSObject; bool flag4 = (obj6 != null) && typeof(IDictionary).IsAssignableFrom(obj6.GetType()); flag2 = ((((PSLanguageMode) this.Command.CommandInfo.DefiningLanguageMode) == PSLanguageMode.FullLanguage) && !flag3) && !flag4; } try { if (flag2) { this.context.LanguageMode = PSLanguageMode.FullLanguage; } result = LanguagePrimitives.ConvertTo(currentValue, toType, Thread.CurrentThread.CurrentCulture); } finally { if (flag2) { this.context.LanguageMode = PSLanguageMode.ConstrainedLanguage; } } bindingTracer.WriteLine("CONVERT SUCCESSFUL using LanguagePrimitives.ConvertTo: [{0}]", new object[] { (result == null) ? "null" : result.ToString() }); return result; } catch (NotSupportedException exception2) { bindingTracer.TraceError("ERROR: COERCE FAILED: arg [{0}] could not be converted to the parameter type [{1}]", new object[] { (result == null) ? "null" : result, toType }); ParameterBindingException exception3 = new ParameterBindingException(exception2, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgument", new object[] { (result == null) ? "null" : result, exception2.Message }); throw exception3; } catch (PSInvalidCastException exception4) { object[] args = new object[] { result ?? "null", toType }; bindingTracer.TraceError("ERROR: COERCE FAILED: arg [{0}] could not be converted to the parameter type [{1}]", args); ParameterBindingException exception5 = new ParameterBindingException(exception4, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgumentNoMessage", new object[] { exception4.Message }); throw exception5; } } return result; }
} // ReparseUnboundArgumentsForBinder private static bool IsSwitchAndSetValue( String argumentName, CommandParameterInternal argument, CompiledCommandParameter matchingParameter) { bool result = false; if (matchingParameter.Type == typeof(SwitchParameter)) { argument.ParameterName = argumentName; argument.SetArgumentValue(PositionUtilities.EmptyExtent, SwitchParameter.Present); result = true; } return result; } // EnsureBoolOrSwitchAndSetValue
internal override bool BindParameter(int parameterSets, CommandParameterInternal argument, MergedCompiledCommandParameter parameter, ParameterBindingFlags flags) { bool flag = true; if ((((flags & ParameterBindingFlags.DelayBindScriptBlock) != ParameterBindingFlags.None) && parameter.Parameter.DoesParameterSetTakePipelineInput(parameterSets)) && argument.ArgumentSpecified) { object argumentValue = argument.ArgumentValue; if (((argumentValue is ScriptBlock) || (argumentValue is DelayedScriptBlockArgument)) && !IsParameterScriptBlockBindable(parameter)) { if (this._commandRuntime.IsClosed && this._commandRuntime.InputPipe.Empty) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.MetadataError, this.Command.MyInvocation, base.GetErrorExtent(argument), parameter.Parameter.Name, parameter.Parameter.Type, null, "ParameterBinderStrings", "ScriptBlockArgumentNoInput", new object[0]); throw exception; } ParameterBinderBase.bindingTracer.WriteLine("Adding ScriptBlock to delay-bind list for parameter '{0}'", new object[] { parameter.Parameter.Name }); DelayedScriptBlockArgument argument2 = argumentValue as DelayedScriptBlockArgument; if (argument2 == null) { argument2 = new DelayedScriptBlockArgument { _argument = argument, _parameterBinder = this }; } if (!this._delayBindScriptBlocks.ContainsKey(parameter)) { this._delayBindScriptBlocks.Add(parameter, argument2); } if (parameter.Parameter.ParameterSetFlags != 0) { base._currentParameterSetFlag &= parameter.Parameter.ParameterSetFlags; } base.UnboundParameters.Remove(parameter); if (!base.BoundParameters.ContainsKey(parameter.Parameter.Name)) { base.BoundParameters.Add(parameter.Parameter.Name, parameter); } if (!base.BoundArguments.ContainsKey(parameter.Parameter.Name)) { base.BoundArguments.Add(parameter.Parameter.Name, argument); } if (base.DefaultParameterBinder.RecordBoundParameters && !base.DefaultParameterBinder.CommandLineParameters.ContainsKey(parameter.Parameter.Name)) { base.DefaultParameterBinder.CommandLineParameters.Add(parameter.Parameter.Name, argument2); } flag = false; } } bool flag2 = false; if (flag) { try { flag2 = this.BindParameter(argument, parameter, flags); } catch (Exception innerException) { bool flag3 = true; if ((flags & ParameterBindingFlags.ShouldCoerceType) == ParameterBindingFlags.None) { while (innerException != null) { if (innerException is PSInvalidCastException) { flag3 = false; break; } innerException = innerException.InnerException; } } if (flag3) { throw; } } } return flag2; }
private bool RestoreParameter(CommandParameterInternal argumentToBind, MergedCompiledCommandParameter parameter) { switch (parameter.BinderAssociation) { case ParameterBinderAssociation.DeclaredFormalParameters: base.DefaultParameterBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue); break; case ParameterBinderAssociation.DynamicParameters: if (this._dynamicParameterBinder != null) { this._dynamicParameterBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue); } break; case ParameterBinderAssociation.CommonParameters: this.CommonParametersBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue); break; case ParameterBinderAssociation.ShouldProcessParameters: this.ShouldProcessParametersBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue); break; case ParameterBinderAssociation.TransactionParameters: this.TransactionParametersBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue); break; case ParameterBinderAssociation.PagingParameters: this.PagingParametersBinder.BindParameter(argumentToBind.ParameterName, argumentToBind.ArgumentValue); break; } return true; }
private void ValidatePSTypeName(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, bool retryOtherBindingAfterFailure, object parameterValue) { if (parameterValue != null) { IEnumerable<string> internalTypeNames = PSObject.AsPSObject(parameterValue).InternalTypeNames; string pSTypeName = parameterMetadata.PSTypeName; if (!internalTypeNames.Contains<string>(pSTypeName, StringComparer.OrdinalIgnoreCase)) { ParameterBindingException exception2; object[] arguments = new object[] { ((this.invocationInfo != null) && (this.invocationInfo.MyCommand != null)) ? this.invocationInfo.MyCommand.Name : string.Empty, parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), 0, 0, pSTypeName }; PSInvalidCastException innerException = new PSInvalidCastException(ErrorCategory.InvalidArgument.ToString(), null, ResourceManagerCache.GetResourceString("ParameterBinderStrings", "MismatchedPSTypeName"), arguments); if (!retryOtherBindingAfterFailure) { exception2 = new ParameterBindingArgumentTransformationException(innerException, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), "ParameterBinderStrings", "MismatchedPSTypeName", new object[] { pSTypeName }); } else { exception2 = new ParameterBindingException(innerException, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), "ParameterBinderStrings", "MismatchedPSTypeName", new object[] { pSTypeName }); } throw exception2; } } }
/// <summary> /// Binds the specified argument to the specified parameter using the appropriate /// parameter binder. If the argument is of type ScriptBlock and the parameter takes /// pipeline input, then the ScriptBlock is saved off in the delay-bind ScriptBlock /// container for further processing of pipeline input and is not bound as the argument /// to the parameter. /// </summary> /// /// <param name="parameterSets"> /// The parameter set used to bind the arguments. /// </param> /// /// <param name="argument"> /// The argument to be bound. /// </param> /// /// <param name="parameter"> /// The metadata for the parameter to bind the argument to. /// </param> /// /// <param name="flags"> /// Flags for type coercion, validation, and script block binding. /// /// ParameterBindingFlags.DelayBindScriptBlock: /// If set, arguments that are of type ScriptBlock where the parameter is not of type ScriptBlock, /// Object, or PSObject will be stored for execution during pipeline input and not bound as /// an argument to the parameter. /// </param> /// /// <returns> /// True if the parameter was successfully bound. False if <paramref name="flags"/> /// has the flag <see cref="ParameterBindingFlags.ShouldCoerceType"/> set and the type does not match the parameter type. /// </returns> /// internal override bool BindParameter( uint parameterSets, CommandParameterInternal argument, MergedCompiledCommandParameter parameter, ParameterBindingFlags flags) { // Now we need to check to see if the argument value is // a ScriptBlock. If it is and the parameter type is // not ScriptBlock and not Object, then we need to delay // binding until a pipeline object is provided to invoke // the ScriptBlock. // Note: we haven't yet determined that only a single parameter // set is valid, so we have to take a best guess on pipeline input // based on the current valid parameter sets. bool continueWithBinding = true; if ((flags & ParameterBindingFlags.DelayBindScriptBlock) != 0 && parameter.Parameter.DoesParameterSetTakePipelineInput(parameterSets) && argument.ArgumentSpecified) { object argumentValue = argument.ArgumentValue; if ((argumentValue is ScriptBlock || argumentValue is DelayedScriptBlockArgument) && !IsParameterScriptBlockBindable(parameter)) { // Now check to see if the command expects to have pipeline input. // If not, we should throw an exception now to inform the // user with more information than they would get if it was // considered an unbound mandatory parameter. if (_commandRuntime.IsClosed && _commandRuntime.InputPipe.Empty) { ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.MetadataError, this.Command.MyInvocation, GetErrorExtent(argument), parameter.Parameter.Name, parameter.Parameter.Type, null, ParameterBinderStrings.ScriptBlockArgumentNoInput, "ScriptBlockArgumentNoInput"); throw bindingException; } ParameterBinderBase.bindingTracer.WriteLine( "Adding ScriptBlock to delay-bind list for parameter '{0}'", parameter.Parameter.Name); // We need to delay binding of this argument to the parameter DelayedScriptBlockArgument delayedArg = argumentValue as DelayedScriptBlockArgument ?? new DelayedScriptBlockArgument { _argument = argument, _parameterBinder = this }; if (!_delayBindScriptBlocks.ContainsKey(parameter)) { _delayBindScriptBlocks.Add(parameter, delayedArg); } // We treat the parameter as bound, but really the // script block gets run for each pipeline object and // the result is bound. if (parameter.Parameter.ParameterSetFlags != 0) { _currentParameterSetFlag &= parameter.Parameter.ParameterSetFlags; } UnboundParameters.Remove(parameter); BoundParameters[parameter.Parameter.Name] = parameter; BoundArguments[parameter.Parameter.Name] = argument; if (DefaultParameterBinder.RecordBoundParameters && !DefaultParameterBinder.CommandLineParameters.ContainsKey(parameter.Parameter.Name)) { DefaultParameterBinder.CommandLineParameters.Add(parameter.Parameter.Name, delayedArg); } continueWithBinding = false; } } bool result = false; if (continueWithBinding) { try { result = BindParameter(argument, parameter, flags); } catch (Exception e) { bool rethrow = true; if ((flags & ParameterBindingFlags.ShouldCoerceType) == 0) { // Attributes are used to do type coercion and result in various exceptions. // We assume that if we aren't trying to do type coercion, we should avoid // propagating type conversion exceptions. while (e != null) { if (e is PSInvalidCastException) { rethrow = false; break; } e = e.InnerException; } } if (rethrow) { throw; } } } return result; }
protected IScriptExtent GetParameterErrorExtent(CommandParameterInternal cpi) { var result = cpi.ParameterExtent; if (result == PositionUtilities.EmptyExtent) result = InvocationInfo.ScriptPosition; // Can't use this assertion - we don't have useful positions when invoked via PowerShell API //Diagnostics.Assert(result != PositionUtilities.EmptyExtent, "We are missing a valid position somewhere"); return result; }
internal void AddParameter(CommandParameterInternal parameter) { this.arguments.Add(parameter); }
/// <summary> /// Passes the binding directly through to the parameter binder. /// It does no verification against metadata. /// </summary> /// <param name="argument"> /// The name and value of the variable to bind. /// </param> /// <param name="flags"> /// Ignored. /// </param> /// <returns> /// True if the parameter was successfully bound. Any error condition /// produces an exception. /// </returns> internal override bool BindParameter(CommandParameterInternal argument, ParameterBindingFlags flags) { // Just pass the binding straight through. No metadata to verify the parameter against. DefaultParameterBinder.BindParameter(argument.ParameterName, argument.ArgumentValue, parameterMetadata: null); return(true); }
private bool BindPositionalParametersInSet( uint validParameterSets, Dictionary<MergedCompiledCommandParameter, PositionalCommandParameter> nextPositionalParameters, CommandParameterInternal argument, ParameterBindingFlags flags, out ParameterBindingException bindingException ) { bool result = false; bindingException = null; foreach (PositionalCommandParameter parameter in nextPositionalParameters.Values) { foreach (ParameterSetSpecificMetadata parameterSetData in parameter.ParameterSetData) { // if the parameter is not in the specified parameter set, don't consider it if ((validParameterSets & parameterSetData.ParameterSetFlag) == 0 && !parameterSetData.IsInAllSets) { continue; } bool bindResult = false; string parameterName = parameter.Parameter.Parameter.Name; ParameterBindingException parameterBindingExceptionToThrown = null; try { CommandParameterInternal bindableArgument = CommandParameterInternal.CreateParameterWithArgument( PositionUtilities.EmptyExtent, parameterName, "-" + parameterName + ":", argument.ArgumentExtent, argument.ArgumentValue, false); bindResult = BindParameter( validParameterSets, bindableArgument, parameter.Parameter, flags); } catch (ParameterBindingArgumentTransformationException pbex) { parameterBindingExceptionToThrown = pbex; } catch (ParameterBindingValidationException pbex) { if (pbex.SwallowException) { // Just ignore and continue bindResult = false; bindingException = pbex; } else { parameterBindingExceptionToThrown = pbex; } } catch (ParameterBindingParameterDefaultValueException pbex) { parameterBindingExceptionToThrown = pbex; } catch (ParameterBindingException e) { // Just ignore and continue; bindResult = false; bindingException = e; } if (parameterBindingExceptionToThrown != null) { if (!DefaultParameterBindingInUse) { throw parameterBindingExceptionToThrown; } else { ThrowElaboratedBindingException(parameterBindingExceptionToThrown); } } if (bindResult) { result = true; this.CommandLineParameters.MarkAsBoundPositionally(parameterName); break; } } } return result; }
/// <summary> /// Bind the argument to the specified parameter /// </summary> /// /// <param name="argument"> /// The argument to be bound. /// </param> /// /// <param name="flags"> /// The flags for type coercion, validation, and script block binding. /// </param> /// /// <returns> /// True if the parameter was successfully bound. False if <paramref name="flags"/> does not have the /// flag <see>ParameterBindingFlags.ShouldCoerceType</see> and the type does not match the parameter type. /// </returns> /// /// <exception cref="ParameterBindingException"> /// If argument transformation fails. /// or /// The argument could not be coerced to the appropriate type for the parameter. /// or /// The parameter argument transformation, prerequisite, or validation failed. /// or /// If the binding to the parameter fails. /// or /// The parameter has already been bound. /// </exception> /// internal virtual bool BindParameter( CommandParameterInternal argument, ParameterBindingFlags flags) { bool result = false; MergedCompiledCommandParameter matchingParameter = BindableParameters.GetMatchingParameter( argument.ParameterName, (flags & ParameterBindingFlags.ThrowOnParameterNotFound) != 0, true, new InvocationInfo(this.InvocationInfo.MyCommand, argument.ParameterExtent)); if (matchingParameter != null) { // Now check to make sure it hasn't already been // bound by looking in the boundParameters collection if (BoundParameters.ContainsKey(matchingParameter.Parameter.Name)) { ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.InvocationInfo, GetParameterErrorExtent(argument), argument.ParameterName, null, null, ParameterBinderStrings.ParameterAlreadyBound, "ParameterAlreadyBound"); throw bindingException; } flags = flags & ~ParameterBindingFlags.DelayBindScriptBlock; result = BindParameter(_currentParameterSetFlag, argument, matchingParameter, flags); } return result; }
/// <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
/// <summary> /// Passes the binding directly through to the parameter binder. /// It does no verification against metadata. /// </summary> /// /// <param name="argument"> /// The name and value of the variable to bind. /// </param> /// /// <param name="flags"> /// Ignored. /// </param> /// /// <returns> /// True if the parameter was successfully bound. Any error condition /// produces an exception. /// </returns> /// internal override bool BindParameter(CommandParameterInternal argument, ParameterBindingFlags flags) { // Just pass the binding straight through. No metadata to verify the parameter against. DefaultParameterBinder.BindParameter(argument.ParameterName, argument.ArgumentValue, parameterMetadata: null); return true; }
private static CommandProcessorBase AddCommand(PipelineProcessor pipe, CommandParameterInternal[] commandElements, CommandBaseAst commandBaseAst, CommandRedirection[] redirections, System.Management.Automation.ExecutionContext context) { object parameterText; IScriptExtent parameterExtent; CommandProcessorBase base2; InternalCommand command; string str3; HelpCategory category; CommandAst ast = commandBaseAst as CommandAst; TokenKind kind = (ast != null) ? ast.InvocationOperator : TokenKind.Unknown; bool dotSource = kind == TokenKind.Dot; SessionStateInternal sessionState = null; int index = 0; PSModuleInfo info = PSObject.Base(commandElements[0].ArgumentValue) as PSModuleInfo; if (info != null) { if ((info.ModuleType == ModuleType.Binary) && (info.SessionState == null)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "CantInvokeInBinaryModule", ParserStrings.CantInvokeInBinaryModule, new object[] { info.Name }); } if (info.SessionState == null) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "CantInvokeInNonImportedModule", ParserStrings.CantInvokeInNonImportedModule, new object[] { info.Name }); } sessionState = info.SessionState.Internal; index++; } CommandParameterInternal internal3 = commandElements[index]; if (internal3.ParameterNameSpecified) { parameterText = internal3.ParameterText; parameterExtent = internal3.ParameterExtent; if (!internal3.ArgumentSpecified) { } } else { parameterText = PSObject.Base(internal3.ArgumentValue); parameterExtent = internal3.ArgumentExtent; } string str = dotSource ? "." : ((kind == TokenKind.Ampersand) ? "&" : null); ScriptBlock scriptblock = parameterText as ScriptBlock; if (scriptblock != null) { base2 = CommandDiscovery.CreateCommandProcessorForScript(scriptblock, context, !dotSource, sessionState); } else { CommandInfo commandInfo = parameterText as CommandInfo; if (commandInfo != null) { base2 = context.CommandDiscovery.LookupCommandProcessor(commandInfo, context.EngineSessionState.CurrentScope.ScopeOrigin, new bool?(!dotSource), sessionState); } else { string str2 = (parameterText as string) ?? PSObject.ToStringParser(context, parameterText); str = str ?? str2; if (string.IsNullOrEmpty(str2)) { throw InterpreterError.NewInterpreterException(parameterText, typeof(RuntimeException), parameterExtent, "BadExpression", ParserStrings.BadExpression, new object[] { dotSource ? "." : "&" }); } try { if (sessionState != null) { SessionStateInternal engineSessionState = context.EngineSessionState; try { context.EngineSessionState = sessionState; base2 = context.CreateCommand(str2, dotSource); goto Label_025D; } finally { context.EngineSessionState = engineSessionState; } } base2 = context.CreateCommand(str2, dotSource); } catch (RuntimeException exception) { if (exception.ErrorRecord.InvocationInfo == null) { InvocationInfo invocationInfo = new InvocationInfo(null, parameterExtent, context) { InvocationName = str }; exception.ErrorRecord.SetInvocationInfo(invocationInfo); } throw; } } } Label_025D: command = base2.Command; base2.UseLocalScope = !dotSource && ((command is ScriptCommand) || (command is PSScriptCmdlet)); bool flag2 = base2 is NativeCommandProcessor; for (int i = index + 1; i < commandElements.Length; i++) { CommandParameterInternal parameter = commandElements[i]; if ((!parameter.ParameterNameSpecified || !parameter.ParameterName.Equals("-", StringComparison.OrdinalIgnoreCase)) || flag2) { if (parameter.ArgumentSplatted) { foreach (CommandParameterInternal internal6 in Splat(parameter.ArgumentValue, parameter.ArgumentExtent)) { base2.AddParameter(internal6); } } else { base2.AddParameter(parameter); } } } if (base2.IsHelpRequested(out str3, out category)) { base2 = CommandProcessorBase.CreateGetHelpCommandProcessor(context, str3, category); } base2.Command.InvocationExtent = commandBaseAst.Extent; base2.Command.MyInvocation.ScriptPosition = commandBaseAst.Extent; base2.Command.MyInvocation.InvocationName = str; pipe.Add(base2); bool flag3 = false; bool flag4 = false; bool flag5 = false; bool flag6 = false; if (redirections != null) { foreach (CommandRedirection redirection in redirections) { redirection.Bind(pipe, base2, context); switch (redirection.FromStream) { case RedirectionStream.All: flag3 = true; flag4 = true; flag5 = true; flag6 = true; break; case RedirectionStream.Error: flag3 = true; break; case RedirectionStream.Warning: flag4 = true; break; case RedirectionStream.Verbose: flag5 = true; break; case RedirectionStream.Debug: flag6 = true; break; } } } if (!flag3) { if (context.ShellFunctionErrorOutputPipe != null) { base2.CommandRuntime.ErrorOutputPipe = context.ShellFunctionErrorOutputPipe; } else { base2.CommandRuntime.ErrorOutputPipe.ExternalWriter = context.ExternalErrorOutput; } } if (!flag4 && (context.ExpressionWarningOutputPipe != null)) { base2.CommandRuntime.WarningOutputPipe = context.ExpressionWarningOutputPipe; flag4 = true; } if (!flag5 && (context.ExpressionVerboseOutputPipe != null)) { base2.CommandRuntime.VerboseOutputPipe = context.ExpressionVerboseOutputPipe; flag5 = true; } if (!flag6 && (context.ExpressionDebugOutputPipe != null)) { base2.CommandRuntime.DebugOutputPipe = context.ExpressionDebugOutputPipe; flag6 = true; } if ((context.CurrentCommandProcessor != null) && (context.CurrentCommandProcessor.CommandRuntime != null)) { if (!flag4 && (context.CurrentCommandProcessor.CommandRuntime.WarningOutputPipe != null)) { base2.CommandRuntime.WarningOutputPipe = context.CurrentCommandProcessor.CommandRuntime.WarningOutputPipe; } if (!flag5 && (context.CurrentCommandProcessor.CommandRuntime.VerboseOutputPipe != null)) { base2.CommandRuntime.VerboseOutputPipe = context.CurrentCommandProcessor.CommandRuntime.VerboseOutputPipe; } if (!flag6 && (context.CurrentCommandProcessor.CommandRuntime.DebugOutputPipe != null)) { base2.CommandRuntime.DebugOutputPipe = context.CurrentCommandProcessor.CommandRuntime.DebugOutputPipe; } } return(base2); }
/// <summary> /// Bind the argument to the specified parameter /// </summary> /// /// <param name="parameterSets"> /// The parameter set used to bind the arguments. /// </param> /// /// <param name="argument"> /// The argument to be bound. /// </param> /// /// <param name="parameter"> /// The metadata for the parameter to bind the argument to. /// </param> /// /// <param name="flags"> /// Flags for type coercion and validation of the arguments. /// </param> /// /// <returns> /// True if the parameter was successfully bound. False if <paramref name="flags"/> /// specifies no type coercion and the type does not match the parameter type. /// </returns> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="parameter"/> or <paramref name="argument"/> is null. /// </exception> /// /// <exception cref="ParameterBindingException"> /// If argument transformation fails. /// or /// The argument could not be coerced to the appropriate type for the parameter. /// or /// The parameter argument transformation, prerequisite, or validation failed. /// or /// If the binding to the parameter fails. /// </exception> /// internal virtual bool BindParameter( uint parameterSets, CommandParameterInternal argument, MergedCompiledCommandParameter parameter, ParameterBindingFlags flags) { bool result = false; switch (parameter.BinderAssociation) { case ParameterBinderAssociation.DeclaredFormalParameters: result = this.DefaultParameterBinder.BindParameter( argument, parameter.Parameter, flags); break; default: Diagnostics.Assert( false, "Only the formal parameters are available for this type of command"); break; } if (result && ((flags & ParameterBindingFlags.IsDefaultValue) == 0)) { UnboundParameters.Remove(parameter); BoundParameters.Add(parameter.Parameter.Name, parameter); } return result; }
private object EncodeCollection(CommandParameterInternal argument, string parameterName, ParameterCollectionTypeInformation collectionTypeInformation, Type toType, object currentValue, bool coerceElementTypeIfNeeded, out bool coercionRequired) { object obj2 = null; coercionRequired = false; bindingTracer.WriteLine("Binding collection parameter {0}: argument type [{1}], parameter type [{2}], collection type {3}, element type [{4}], {5}", new object[] { parameterName, (currentValue == null) ? "null" : currentValue.GetType().Name, toType, collectionTypeInformation.ParameterCollectionType, collectionTypeInformation.ElementType, coerceElementTypeIfNeeded ? "coerceElementType" : "no coerceElementType" }); if (currentValue != null) { int length = 1; Type elementType = collectionTypeInformation.ElementType; IList iList = GetIList(currentValue); if (iList != null) { length = iList.Count; tracer.WriteLine("current value is an IList with {0} elements", new object[] { length }); bindingTracer.WriteLine("Arg is IList with {0} elements", new object[] { length }); } object obj3 = null; IList list2 = null; MethodInfo info = null; bool flag = toType == typeof(Array); if ((collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) || flag) { if (flag) { elementType = typeof(object); } bindingTracer.WriteLine("Creating array with element type [{0}] and {1} elements", new object[] { elementType, length }); obj3 = list2 = Array.CreateInstance(elementType, length); } else { if ((collectionTypeInformation.ParameterCollectionType != ParameterCollectionType.IList) && (collectionTypeInformation.ParameterCollectionType != ParameterCollectionType.ICollectionGeneric)) { return obj2; } bindingTracer.WriteLine("Creating collection [{0}]", new object[] { toType }); bool flag2 = false; Exception innerException = null; try { obj3 = Activator.CreateInstance(toType, BindingFlags.Default, null, new object[0], CultureInfo.InvariantCulture); if (collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.IList) { list2 = (IList) obj3; } else { Type type2 = collectionTypeInformation.ElementType; BindingFlags bindingAttr = BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance; Exception exception2 = null; try { info = toType.GetMethod("Add", bindingAttr, null, new Type[] { type2 }, null); } catch (AmbiguousMatchException exception3) { bindingTracer.WriteLine("Ambiguous match to Add(T) for type " + toType.FullName + ": " + exception3.Message, new object[0]); exception2 = exception3; } catch (ArgumentException exception4) { bindingTracer.WriteLine("ArgumentException matching Add(T) for type " + toType.FullName + ": " + exception4.Message, new object[0]); exception2 = exception4; } if (null == info) { ParameterBindingException exception5 = new ParameterBindingException(exception2, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, (currentValue == null) ? null : currentValue.GetType(), "ParameterBinderStrings", "CannotExtractAddMethod", new object[] { (exception2 == null) ? "" : exception2.Message }); throw exception5; } } } catch (ArgumentException exception6) { flag2 = true; innerException = exception6; } catch (NotSupportedException exception7) { flag2 = true; innerException = exception7; } catch (TargetInvocationException exception8) { flag2 = true; innerException = exception8; } catch (MethodAccessException exception9) { flag2 = true; innerException = exception9; } catch (MemberAccessException exception10) { flag2 = true; innerException = exception10; } catch (InvalidComObjectException exception11) { flag2 = true; innerException = exception11; } catch (COMException exception12) { flag2 = true; innerException = exception12; } catch (TypeLoadException exception13) { flag2 = true; innerException = exception13; } if (flag2) { ParameterBindingException exception14 = new ParameterBindingException(innerException, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, currentValue.GetType(), "ParameterBinderStrings", "CannotConvertArgument", new object[] { (obj2 == null) ? "null" : obj2, (innerException == null) ? "" : innerException.Message }); throw exception14; } } if (iList != null) { int num2 = 0; bindingTracer.WriteLine("Argument type {0} is IList", new object[] { currentValue.GetType() }); foreach (object obj4 in iList) { object obj5 = PSObject.Base(obj4); if (coerceElementTypeIfNeeded) { bindingTracer.WriteLine("COERCE collection element from type {0} to type {1}", new object[] { (obj4 == null) ? "null" : obj4.GetType().Name, elementType }); obj5 = this.CoerceTypeAsNeeded(argument, parameterName, elementType, null, obj4); } else if ((null != elementType) && (obj5 != null)) { Type type = obj5.GetType(); Type c = elementType; if ((type != c) && !type.IsSubclassOf(c)) { bindingTracer.WriteLine("COERCION REQUIRED: Did not attempt to coerce collection element from type {0} to type {1}", new object[] { (obj4 == null) ? "null" : obj4.GetType().Name, elementType }); coercionRequired = true; break; } } try { if ((collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) || flag) { bindingTracer.WriteLine("Adding element of type {0} to array position {1}", new object[] { (obj5 == null) ? "null" : obj5.GetType().Name, num2 }); list2[num2++] = obj5; } else if (collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.IList) { bindingTracer.WriteLine("Adding element of type {0} via IList.Add", new object[] { (obj5 == null) ? "null" : obj5.GetType().Name }); list2.Add(obj5); } else { bindingTracer.WriteLine("Adding element of type {0} via ICollection<T>::Add()", new object[] { (obj5 == null) ? "null" : obj5.GetType().Name }); info.Invoke(obj3, new object[] { obj5 }); } } catch (Exception exception15) { CommandProcessorBase.CheckForSevereException(exception15); if ((exception15 is TargetInvocationException) && (exception15.InnerException != null)) { exception15 = exception15.InnerException; } ParameterBindingException exception16 = new ParameterBindingException(exception15, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, (obj5 == null) ? null : obj5.GetType(), "ParameterBinderStrings", "CannotConvertArgument", new object[] { (obj5 == null) ? "null" : obj5, exception15.Message }); throw exception16; } } } else { bindingTracer.WriteLine("Argument type {0} is not IList, treating this as scalar", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name }); if (elementType != null) { if (coerceElementTypeIfNeeded) { bindingTracer.WriteLine("Coercing scalar arg value to type {0}", new object[] { elementType }); currentValue = this.CoerceTypeAsNeeded(argument, parameterName, elementType, null, currentValue); } else { Type type5 = currentValue.GetType(); Type type6 = elementType; if ((type5 != type6) && !type5.IsSubclassOf(type6)) { bindingTracer.WriteLine("COERCION REQUIRED: Did not coerce scalar arg value to type {1}", new object[] { elementType }); coercionRequired = true; return obj2; } } } try { if ((collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) || flag) { bindingTracer.WriteLine("Adding scalar element of type {0} to array position {1}", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name, 0 }); list2[0] = currentValue; } else if (collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.IList) { bindingTracer.WriteLine("Adding scalar element of type {0} via IList.Add", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name }); list2.Add(currentValue); } else { bindingTracer.WriteLine("Adding scalar element of type {0} via ICollection<T>::Add()", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name }); info.Invoke(obj3, new object[] { currentValue }); } } catch (Exception exception17) { CommandProcessorBase.CheckForSevereException(exception17); if ((exception17 is TargetInvocationException) && (exception17.InnerException != null)) { exception17 = exception17.InnerException; } ParameterBindingException exception18 = new ParameterBindingException(exception17, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, (currentValue == null) ? null : currentValue.GetType(), "ParameterBinderStrings", "CannotConvertArgument", new object[] { (currentValue == null) ? "null" : currentValue, exception17.Message }); throw exception18; } } if (!coercionRequired) { obj2 = obj3; } } return obj2; }
internal virtual bool BindParameter(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, ParameterBindingFlags flags) { bool flag = false; bool flag2 = (flags & ParameterBindingFlags.ShouldCoerceType) != ParameterBindingFlags.None; if (parameter == null) { throw PSTraceSource.NewArgumentNullException("parameter"); } if (parameterMetadata == null) { throw PSTraceSource.NewArgumentNullException("parameterMetadata"); } using (bindingTracer.TraceScope("BIND arg [{0}] to parameter [{1}]", new object[] { parameter.ArgumentValue, parameterMetadata.Name })) { parameter.ParameterName = parameterMetadata.Name; object argumentValue = parameter.ArgumentValue; ScriptParameterBinder binder = this as ScriptParameterBinder; bool bindingScriptCmdlet = false; if (binder != null) { bindingScriptCmdlet = binder.Script.UsesCmdletBinding; } foreach (ArgumentTransformationAttribute attribute in parameterMetadata.ArgumentTransformationAttributes) { using (bindingTracer.TraceScope("Executing DATA GENERATION metadata: [{0}]", new object[] { attribute.GetType() })) { try { ArgumentTypeConverterAttribute attribute2 = attribute as ArgumentTypeConverterAttribute; if (attribute2 != null) { if (flag2) { argumentValue = attribute2.Transform(this.engine, argumentValue, true, bindingScriptCmdlet); } } else { argumentValue = attribute.Transform(this.engine, argumentValue); } bindingTracer.WriteLine("result returned from DATA GENERATION: {0}", new object[] { argumentValue }); } catch (Exception exception) { CommandProcessorBase.CheckForSevereException(exception); bindingTracer.WriteLine("ERROR: DATA GENERATION: {0}", new object[] { exception.Message }); ParameterBindingException exception2 = new ParameterBindingArgumentTransformationException(exception, ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (argumentValue == null) ? null : argumentValue.GetType(), "ParameterBinderStrings", "ParameterArgumentTransformationError", new object[] { exception.Message }); throw exception2; } } } if (flag2) { argumentValue = this.CoerceTypeAsNeeded(parameter, parameterMetadata.Name, parameterMetadata.Type, parameterMetadata.CollectionTypeInformation, argumentValue); } else if (!this.ShouldContinueUncoercedBind(parameter, parameterMetadata, flags, ref argumentValue)) { goto Label_040E; } if ((parameterMetadata.PSTypeName != null) && (argumentValue != null)) { IEnumerable enumerable = LanguagePrimitives.GetEnumerable(argumentValue); if (enumerable != null) { foreach (object obj3 in enumerable) { this.ValidatePSTypeName(parameter, parameterMetadata, !flag2, obj3); } } else { this.ValidatePSTypeName(parameter, parameterMetadata, !flag2, argumentValue); } } if ((flags & ParameterBindingFlags.IsDefaultValue) == ParameterBindingFlags.None) { foreach (ValidateArgumentsAttribute attribute3 in parameterMetadata.ValidationAttributes) { using (bindingTracer.TraceScope("Executing VALIDATION metadata: [{0}]", new object[] { attribute3.GetType() })) { try { attribute3.InternalValidate(argumentValue, this.engine); } catch (Exception exception3) { CommandProcessorBase.CheckForSevereException(exception3); bindingTracer.WriteLine("ERROR: VALIDATION FAILED: {0}", new object[] { exception3.Message }); ParameterBindingValidationException exception4 = new ParameterBindingValidationException(exception3, ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (argumentValue == null) ? null : argumentValue.GetType(), "ParameterBinderStrings", "ParameterArgumentValidationError", new object[] { exception3.Message }); throw exception4; } tracer.WriteLine("Validation attribute on {0} returned {1}.", new object[] { parameterMetadata.Name, flag }); } } if (IsParameterMandatory(parameterMetadata)) { this.ValidateNullOrEmptyArgument(parameter, parameterMetadata, parameterMetadata.Type, argumentValue, true); } } Exception innerException = null; try { this.BindParameter(parameter.ParameterName, argumentValue); flag = true; } catch (SetValueException exception6) { innerException = exception6; } if (innerException != null) { Type typeSpecified = (argumentValue == null) ? null : argumentValue.GetType(); ParameterBindingException exception7 = new ParameterBindingException(innerException, ErrorCategory.WriteError, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, typeSpecified, "ParameterBinderStrings", "ParameterBindingFailed", new object[] { innerException.Message }); throw exception7; } Label_040E:; bindingTracer.WriteLine("BIND arg [{0}] to param [{1}] {2}", new object[] { argumentValue, parameter.ParameterName, flag ? "SUCCESSFUL" : "SKIPPED" }); if (flag) { if (this.RecordBoundParameters) { this.CommandLineParameters.Add(parameter.ParameterName, argumentValue); } MshCommandRuntime commandRuntime = this.Command.commandRuntime as MshCommandRuntime; if ((commandRuntime != null) && commandRuntime.LogPipelineExecutionDetail) { IEnumerable source = LanguagePrimitives.GetEnumerable(argumentValue); if (source != null) { string parameterValue = string.Join(", ", source.Cast<object>().ToArray<object>()); commandRuntime.PipelineProcessor.LogExecutionParameterBinding(this.InvocationInfo, parameter.ParameterName, parameterValue); } else { commandRuntime.PipelineProcessor.LogExecutionParameterBinding(this.InvocationInfo, parameter.ParameterName, (argumentValue == null) ? "" : argumentValue.ToString()); } } } return flag; } }