private Collection <AstParameterArgumentPair> BindPositionalParameter(Collection <AstParameterArgumentPair> unboundArguments, int validParameterSetFlags, int defaultParameterSetFlag, bool honorDefaultParameterSet) { Collection <AstParameterArgumentPair> nonPositionalArguments = new Collection <AstParameterArgumentPair>(); if (this._bindingEffective && (unboundArguments.Count > 0)) { SortedDictionary <int, Dictionary <MergedCompiledCommandParameter, PositionalCommandParameter> > dictionary; List <AstParameterArgumentPair> unboundArgumentsCollection = new List <AstParameterArgumentPair>(unboundArguments); try { dictionary = ParameterBinderController.EvaluateUnboundPositionalParameters(this._unboundParameters, validParameterSetFlags); } catch (InvalidOperationException) { this._bindingEffective = false; return(nonPositionalArguments); } if (dictionary.Count == 0) { return(unboundArguments); } int unboundArgumentsIndex = 0; foreach (Dictionary <MergedCompiledCommandParameter, PositionalCommandParameter> dictionary2 in dictionary.Values) { if (dictionary2.Count != 0) { AstParameterArgumentPair argument = GetNextPositionalArgument(unboundArgumentsCollection, nonPositionalArguments, ref unboundArgumentsIndex); if (argument == null) { break; } bool flag = false; if ((honorDefaultParameterSet && (defaultParameterSetFlag != 0)) && ((validParameterSetFlags & defaultParameterSetFlag) != 0)) { flag = this.BindPseudoPositionalParameterInSet(defaultParameterSetFlag, dictionary2, argument, false); } if (!flag) { flag = this.BindPseudoPositionalParameterInSet(validParameterSetFlags, dictionary2, argument, true); } if (!flag) { nonPositionalArguments.Add(argument); } else if (validParameterSetFlags != this._currentParameterSetFlag) { validParameterSetFlags = this._currentParameterSetFlag; ParameterBinderController.UpdatePositionalDictionary(dictionary, validParameterSetFlags); } } } for (int i = unboundArgumentsIndex; i < unboundArgumentsCollection.Count; i++) { nonPositionalArguments.Add(unboundArgumentsCollection[i]); } } return(nonPositionalArguments); }
private static AstParameterArgumentPair GetNextPositionalArgument(List <AstParameterArgumentPair> unboundArgumentsCollection, Collection <AstParameterArgumentPair> nonPositionalArguments, ref int unboundArgumentsIndex) { while (unboundArgumentsIndex < unboundArgumentsCollection.Count) { AstParameterArgumentPair item = unboundArgumentsCollection[unboundArgumentsIndex++]; if (!item.ParameterSpecified) { return(item); } nonPositionalArguments.Add(item); } return(null); }
private IEnumerable <PSTypeName> GetInferredTypeFromScriptBlockParameter(AstParameterArgumentPair argument, CompletionContext context) { AstPair iteratorVariable0 = argument as AstPair; if ((iteratorVariable0 != null) && (iteratorVariable0.Argument is ScriptBlockExpressionAst)) { ScriptBlockExpressionAst iteratorVariable1 = (ScriptBlockExpressionAst)iteratorVariable0.Argument; foreach (PSTypeName iteratorVariable2 in iteratorVariable1.ScriptBlock.GetInferredType(context)) { yield return(iteratorVariable2); } } }
private bool ParseParameterArguments(CommandParameterAst paramAstAtCursor) { if (!this._bindingEffective) { return(this._bindingEffective); } Collection <AstParameterArgumentPair> collection = new Collection <AstParameterArgumentPair>(); for (int i = 0; i < this._arguments.Count; i++) { AstParameterArgumentPair item = this._arguments[i]; if (!item.ParameterSpecified || item.ArgumentSpecified) { collection.Add(item); } else { string parameterName = item.ParameterName; MergedCompiledCommandParameter parameter = null; try { bool tryExactMatching = item.Parameter != paramAstAtCursor; parameter = this._bindableParameters.GetMatchingParameter(parameterName, false, tryExactMatching, null); } catch (ParameterBindingException) { this._ambiguousParameters.Add(item.Parameter); goto Label_01F1; } if (parameter == null) { if (i < (this._arguments.Count - 1)) { AstParameterArgumentPair pair2 = this._arguments[i + 1]; if (!pair2.ParameterSpecified && pair2.ArgumentSpecified) { this._arguments = null; return(false); } } this._parametersNotFound.Add(item.Parameter); } else if (parameter.Parameter.Type == typeof(SwitchParameter)) { SwitchPair pair3 = new SwitchPair(item.Parameter); collection.Add(pair3); } else if (i < (this._arguments.Count - 1)) { AstParameterArgumentPair pair4 = this._arguments[i + 1]; if (pair4.ParameterSpecified) { try { if (this._bindableParameters.GetMatchingParameter(pair4.ParameterName, false, true, null) == null) { AstPair pair5 = new AstPair(item.Parameter, pair4.Parameter); collection.Add(pair5); i++; } else { FakePair pair6 = new FakePair(item.Parameter); collection.Add(pair6); } goto Label_01F1; } catch (ParameterBindingException) { FakePair pair7 = new FakePair(item.Parameter); collection.Add(pair7); goto Label_01F1; } } AstPair pair8 = pair4 as AstPair; AstPair pair9 = new AstPair(item.Parameter, (ExpressionAst)pair8.Argument); collection.Add(pair9); i++; } else { FakePair pair10 = new FakePair(item.Parameter); collection.Add(pair10); } Label_01F1 :; } } this._arguments = collection; return(true); }
private bool BindPseudoPositionalParameterInSet(int validParameterSetFlag, Dictionary <MergedCompiledCommandParameter, PositionalCommandParameter> nextPositionalParameters, AstParameterArgumentPair argument, bool typeConversion) { bool flag = false; int num = 0; foreach (PositionalCommandParameter parameter in nextPositionalParameters.Values) { foreach (ParameterSetSpecificMetadata metadata in parameter.ParameterSetData) { if (((validParameterSetFlag & metadata.ParameterSetFlag) != 0) || metadata.IsInAllSets) { bool flag2 = false; string name = parameter.Parameter.Parameter.Name; Type paramType = parameter.Parameter.Parameter.Type; Type argumentType = argument.ArgumentType; if (argumentType.Equals(typeof(object))) { flag = flag2 = true; } else if (IsTypeEquivalent(argumentType, paramType)) { flag = flag2 = true; } else if (typeConversion) { flag = flag2 = true; } if (flag2) { num |= parameter.Parameter.Parameter.ParameterSetFlags; this._unboundParameters.Remove(parameter.Parameter); if (!this._boundParameters.ContainsKey(name)) { this._boundParameters.Add(name, parameter.Parameter); this._boundPositionalParameter.Add(name); } if (!this._boundArguments.ContainsKey(name)) { this._boundArguments.Add(name, argument); } break; } } } } if (flag && (num != 0)) { this._currentParameterSetFlag &= num; } return(flag); }
private IEnumerable<PSTypeName> GetInferredTypeFromScriptBlockParameter(AstParameterArgumentPair argument, CompletionContext context) { AstPair iteratorVariable0 = argument as AstPair; if ((iteratorVariable0 != null) && (iteratorVariable0.Argument is ScriptBlockExpressionAst)) { ScriptBlockExpressionAst iteratorVariable1 = (ScriptBlockExpressionAst) iteratorVariable0.Argument; foreach (PSTypeName iteratorVariable2 in iteratorVariable1.ScriptBlock.GetInferredType(context)) { yield return iteratorVariable2; } } }
private bool BindPseudoPositionalParameterInSet( uint validParameterSetFlag, Dictionary<MergedCompiledCommandParameter, PositionalCommandParameter> nextPositionalParameters, AstParameterArgumentPair argument, bool typeConversion) { bool bindingSuccessful = false; uint localParameterSetFlag = 0; foreach (PositionalCommandParameter parameter in nextPositionalParameters.Values) { foreach (ParameterSetSpecificMetadata parameterSetData in parameter.ParameterSetData) { // Skip it if it's not in the specified parameter set if ((validParameterSetFlag & parameterSetData.ParameterSetFlag) == 0 && !parameterSetData.IsInAllSets) { continue; } bool result = false; string parameterName = parameter.Parameter.Parameter.Name; Type parameterType = parameter.Parameter.Parameter.Type; Type argumentType = argument.ArgumentType; // 1. the argument type is not known(typeof(object)). we assume the binding always succeeds // 2. the argument type is the same as parameter type, we assume the binding succeeds // 3. the types are not the same, but we allow conversion, we assume the binding succeeds // 4. the types are not the same, and conversion is not allowed, we assume the binding fails if (argumentType == typeof(object)) bindingSuccessful = result = true; else if (IsTypeEquivalent(argumentType, parameterType)) bindingSuccessful = result = true; else if (typeConversion) bindingSuccessful = result = true; if (result) { localParameterSetFlag |= parameter.Parameter.Parameter.ParameterSetFlags; _unboundParameters.Remove(parameter.Parameter); if (!_boundParameters.ContainsKey(parameterName)) { _boundParameters.Add(parameterName, parameter.Parameter); _boundPositionalParameter.Add(parameterName); } if (!_boundArguments.ContainsKey(parameterName)) { _boundArguments.Add(parameterName, argument); } break; } } } // We preserve all posibilities if (bindingSuccessful && localParameterSetFlag != 0) _currentParameterSetFlag &= localParameterSetFlag; return bindingSuccessful; }
private bool BindPseudoPositionalParameterInSet(int validParameterSetFlag, Dictionary<MergedCompiledCommandParameter, PositionalCommandParameter> nextPositionalParameters, AstParameterArgumentPair argument, bool typeConversion) { bool flag = false; int num = 0; foreach (PositionalCommandParameter parameter in nextPositionalParameters.Values) { foreach (ParameterSetSpecificMetadata metadata in parameter.ParameterSetData) { if (((validParameterSetFlag & metadata.ParameterSetFlag) != 0) || metadata.IsInAllSets) { bool flag2 = false; string name = parameter.Parameter.Parameter.Name; Type paramType = parameter.Parameter.Parameter.Type; Type argumentType = argument.ArgumentType; if (argumentType.Equals(typeof(object))) { flag = flag2 = true; } else if (IsTypeEquivalent(argumentType, paramType)) { flag = flag2 = true; } else if (typeConversion) { flag = flag2 = true; } if (flag2) { num |= parameter.Parameter.Parameter.ParameterSetFlags; this._unboundParameters.Remove(parameter.Parameter); if (!this._boundParameters.ContainsKey(name)) { this._boundParameters.Add(name, parameter.Parameter); this._boundPositionalParameter.Add(name); } if (!this._boundArguments.ContainsKey(name)) { this._boundArguments.Add(name, argument); } break; } } } } if (flag && (num != 0)) { this._currentParameterSetFlag &= num; } return flag; }