/// <summary>
/// Extracts the data from the ParameterAttribute and creates the member data as necessary.
/// </summary>
/// <param name="parameterName">
/// The name of the parameter.
/// </param>
/// <param name="parameter">
/// The instance of the ParameterAttribute to extract the data from.
/// </param>
/// <exception cref="MetadataException">
/// If a parameter set name has already been declared on this parameter.
/// </exception>
private void ProcessParameterAttribute(
string parameterName,
ParameterAttribute parameter)
{
// If the parameter set name already exists on this parameter and the set name is the default parameter
// set name, it is an error.
if (ParameterSetData.ContainsKey(parameter.ParameterSetName))
{
MetadataException e =
new MetadataException(
"ParameterDeclaredInParameterSetMultipleTimes",
null,
DiscoveryExceptions.ParameterDeclaredInParameterSetMultipleTimes,
parameterName,
parameter.ParameterSetName);
throw e;
}
if (parameter.ValueFromPipeline || parameter.ValueFromPipelineByPropertyName)
{
IsPipelineParameterInSomeParameterSet = true;
}
if (parameter.Mandatory)
{
IsMandatoryInSomeParameterSet = true;
}
// Construct an instance of the parameter set specific data
ParameterSetSpecificMetadata parameterSetSpecificData = new ParameterSetSpecificMetadata(parameter);
ParameterSetData.Add(parameter.ParameterSetName, parameterSetSpecificData);
}
private static void AddNewPosition(SortedDictionary<int, Dictionary<MergedCompiledCommandParameter, PositionalCommandParameter>> result, int positionInParameterSet, MergedCompiledCommandParameter parameter, ParameterSetSpecificMetadata parameterSetData)
{
if (result.ContainsKey(positionInParameterSet))
{
Dictionary<MergedCompiledCommandParameter, PositionalCommandParameter> positionalCommandParameters = result[positionInParameterSet];
if (ContainsPositionalParameterInSet(positionalCommandParameters, parameter, parameterSetData.ParameterSetFlag))
{
throw PSTraceSource.NewInvalidOperationException();
}
if (positionalCommandParameters.ContainsKey(parameter))
{
positionalCommandParameters[parameter].ParameterSetData.Add(parameterSetData);
}
else
{
PositionalCommandParameter parameter2 = new PositionalCommandParameter(parameter);
parameter2.ParameterSetData.Add(parameterSetData);
positionalCommandParameters.Add(parameter, parameter2);
}
}
else
{
Dictionary<MergedCompiledCommandParameter, PositionalCommandParameter> dictionary2 = new Dictionary<MergedCompiledCommandParameter, PositionalCommandParameter>();
PositionalCommandParameter parameter3 = new PositionalCommandParameter(parameter) {
ParameterSetData = { parameterSetData }
};
dictionary2.Add(parameter, parameter3);
result.Add(positionInParameterSet, dictionary2);
}
}
internal uint GenerateParameterSetMappingFromMetadata(string defaultParameterSetName)
{
this.parameterSetMap.Clear();
this.nextAvailableParameterSetIndex = 0U;
uint num1 = 0;
if (!string.IsNullOrEmpty(defaultParameterSetName))
{
this._defaultParameterSetName = defaultParameterSetName;
num1 = (uint)(1 << this.AddParameterSetToMap(defaultParameterSetName, (CompiledCommandParameter)null));
}
foreach (MergedCompiledCommandParameter commandParameter in this.BindableParameters.Values)
{
uint num2 = 0;
foreach (string key in commandParameter.Parameter.ParameterSetData.Keys)
{
if (string.Equals(key, "__AllParameterSets", StringComparison.OrdinalIgnoreCase))
{
ParameterSetSpecificMetadata specificMetadata = commandParameter.Parameter.ParameterSetData[key];
specificMetadata.ParameterSetFlag = 0U;
specificMetadata.IsInAllSets = true;
commandParameter.Parameter.IsInAllSets = true;
}
else
{
uint num3 = (uint)(1 << this.AddParameterSetToMap(key, commandParameter.Parameter));
num2 |= num3;
commandParameter.Parameter.ParameterSetData[key].ParameterSetFlag = num3;
}
}
commandParameter.Parameter.ParameterSetFlags = num2;
}
return(num1);
}
/// <summary>
/// Gets the parameter set data for this parameter for the specified parameter set.
/// </summary>
/// <param name="parameterSetFlag">
/// The parameter set to get the parameter set data for.
/// </param>
/// <returns>
/// The parameter set specified data for the specified parameter set.
/// </returns>
internal ParameterSetSpecificMetadata GetParameterSetData(uint parameterSetFlag)
{
ParameterSetSpecificMetadata result = null;
foreach (ParameterSetSpecificMetadata setData in ParameterSetData.Values)
{
// If the parameter is in all sets, then remember the data, but
// try to find a more specific match
if (setData.IsInAllSets)
{
result = setData;
}
else
{
if ((setData.ParameterSetFlag & parameterSetFlag) != 0)
{
result = setData;
break;
}
}
}
return(result);
}
private void SetParameterSetData(ParameterSetSpecificMetadata parameterMetadata)
{
IsMandatory = parameterMetadata.IsMandatory;
Position = parameterMetadata.Position;
ValueFromPipeline = parameterMetadata.valueFromPipeline;
ValueFromPipelineByPropertyName = parameterMetadata.valueFromPipelineByPropertyName;
ValueFromRemainingArguments = parameterMetadata.ValueFromRemainingArguments;
HelpMessage = parameterMetadata.HelpMessage;
}
private void SetParameterSetData(ParameterSetSpecificMetadata parameterMetadata)
{
this.isMandatory = parameterMetadata.IsMandatory;
this.position = parameterMetadata.Position;
this.valueFromPipeline = parameterMetadata.valueFromPipeline;
this.valueFromPipelineByPropertyName = parameterMetadata.valueFromPipelineByPropertyName;
this.valueFromRemainingArguments = parameterMetadata.ValueFromRemainingArguments;
this.helpMessage = parameterMetadata.HelpMessage;
}
internal void Initialize(ParameterSetSpecificMetadata psMD)
{
this.isMandatory = psMD.IsMandatory;
this.position = psMD.Position;
this.valueFromPipeline = psMD.ValueFromPipeline;
this.valueFromPipelineByPropertyName = psMD.ValueFromPipelineByPropertyName;
this.valueFromRemainingArguments = psMD.ValueFromRemainingArguments;
this.helpMessage = psMD.HelpMessage;
this.helpMessageBaseName = psMD.HelpMessageBaseName;
this.helpMessageResourceId = psMD.HelpMessageResourceId;
}
private void SetParameterSetData(ParameterSetSpecificMetadata parameterMetadata)
{
using (CommandParameterInfo.tracer.TraceMethod())
{
this.isMandatory = parameterMetadata.IsMandatory;
this.position = parameterMetadata.Position;
this.valueFromPipeline = parameterMetadata.valueFromPipeline;
this.valueFromPipelineByPropertyName = parameterMetadata.valueFromPipelineByPropertyName;
this.valueFromRemainingArguments = parameterMetadata.ValueFromRemainingArguments;
this.helpMessage = parameterMetadata.HelpMessage;
}
}
internal ParameterSetSpecificMetadata GetParameterSetData(int parameterSetFlag)
{
ParameterSetSpecificMetadata metadata = null;
foreach (ParameterSetSpecificMetadata metadata2 in this.ParameterSetData.Values)
{
if (metadata2.IsInAllSets)
{
metadata = metadata2;
}
else if ((metadata2.ParameterSetFlag & parameterSetFlag) != 0)
{
return(metadata2);
}
}
return(metadata);
}
private void ProcessParameterAttribute(string parameterName, ParameterAttribute parameter)
{
if (this._parameterSetData.ContainsKey(parameter.ParameterSetName))
{
System.Management.Automation.MetadataException exception = new System.Management.Automation.MetadataException("ParameterDeclaredInParameterSetMultipleTimes", null, DiscoveryExceptions.ParameterDeclaredInParameterSetMultipleTimes, new object[] { parameterName, parameter.ParameterSetName });
throw exception;
}
if (parameter.ValueFromPipeline || parameter.ValueFromPipelineByPropertyName)
{
this._isPipelineParameterInSomeParameterSet = true;
}
if (parameter.Mandatory)
{
this._isMandatoryInSomeParameterSet = true;
}
ParameterSetSpecificMetadata metadata = new ParameterSetSpecificMetadata(parameter);
this._parameterSetData.Add(parameter.ParameterSetName, metadata);
}
internal void Initialize(CompiledCommandParameter compiledParameterMD)
{
this.name = compiledParameterMD.Name;
this.parameterType = compiledParameterMD.Type;
this.isDynamic = compiledParameterMD.IsDynamic;
this.parameterSets = new Dictionary <string, ParameterSetMetadata>(StringComparer.OrdinalIgnoreCase);
foreach (string str in compiledParameterMD.ParameterSetData.Keys)
{
ParameterSetSpecificMetadata psMD = compiledParameterMD.ParameterSetData[str];
this.parameterSets.Add(str, new ParameterSetMetadata(psMD));
}
this.aliases = new Collection <string>();
foreach (string str2 in compiledParameterMD.Aliases)
{
this.aliases.Add(str2);
}
this.attributes = new Collection <Attribute>();
foreach (Attribute attribute in compiledParameterMD.CompiledAttributes)
{
this.attributes.Add(attribute);
}
}
private void BuildSyntaxForParameterSet(XmlElement command, XmlElement syntax, MergedCommandParameterMetadata parameterMetadata, int i)
{
XmlElement newChild = this.doc.CreateElement("command:syntaxItem", commandURI);
XmlElement element2 = this.doc.CreateElement("maml:name", mamlURI);
XmlText text = this.doc.CreateTextNode(this.commandName);
newChild.AppendChild(element2).AppendChild(text);
foreach (MergedCompiledCommandParameter parameter in parameterMetadata.GetParametersInParameterSet(((int)1) << i))
{
if (parameter.BinderAssociation != ParameterBinderAssociation.CommonParameters)
{
CompiledCommandParameter parameter2 = parameter.Parameter;
ParameterSetSpecificMetadata parameterSetData = parameter2.GetParameterSetData(((int)1) << i);
string parameterDescription = this.GetParameterDescription(parameter2.Name);
bool supportsWildcards = (from attribute in parameter2.CompiledAttributes
where attribute is SupportsWildcardsAttribute
select attribute).Any <System.Attribute>();
XmlElement element3 = this.BuildXmlForParameter(parameter2.Name, parameterSetData.IsMandatory, parameterSetData.ValueFromPipeline, parameterSetData.ValueFromPipelineByPropertyName, parameterSetData.IsPositional ? ((1 + parameterSetData.Position)).ToString(CultureInfo.InvariantCulture) : "named", parameter2.Type, parameterDescription, supportsWildcards, "", true);
newChild.AppendChild(element3);
}
}
command.AppendChild(syntax).AppendChild(newChild);
}
internal int GenerateParameterSetMappingFromMetadata(string defaultParameterSetName)
{
this.parameterSetMap.Clear();
this.nextAvailableParameterSetIndex = 0;
int num = 0;
if (!string.IsNullOrEmpty(defaultParameterSetName))
{
this._defaultParameterSetName = defaultParameterSetName;
int num2 = this.AddParameterSetToMap(defaultParameterSetName);
num = ((int)1) << num2;
}
foreach (MergedCompiledCommandParameter parameter in this.BindableParameters.Values)
{
int num3 = 0;
foreach (KeyValuePair <string, ParameterSetSpecificMetadata> pair in parameter.Parameter.ParameterSetData)
{
string key = pair.Key;
ParameterSetSpecificMetadata metadata = pair.Value;
if (string.Equals(key, "__AllParameterSets", StringComparison.OrdinalIgnoreCase))
{
metadata.ParameterSetFlag = 0;
metadata.IsInAllSets = true;
parameter.Parameter.IsInAllSets = true;
}
else
{
int num4 = this.AddParameterSetToMap(key);
int num5 = ((int)1) << num4;
num3 |= num5;
metadata.ParameterSetFlag = num5;
}
}
parameter.Parameter.ParameterSetFlags = num3;
}
return(num);
}
private void BuildSyntaxForParameterSet(
XmlElement command,
XmlElement syntax,
MergedCommandParameterMetadata parameterMetadata,
int i)
{
XmlElement element1 = this.doc.CreateElement("command:syntaxItem", HelpCommentsParser.commandURI);
XmlElement element2 = this.doc.CreateElement("maml:name", HelpCommentsParser.mamlURI);
XmlText textNode = this.doc.CreateTextNode(this.commandName);
element1.AppendChild((XmlNode)element2).AppendChild((XmlNode)textNode);
foreach (MergedCompiledCommandParameter parametersInParameter in parameterMetadata.GetParametersInParameterSet((uint)(1 << i)))
{
if (parametersInParameter.BinderAssociation != ParameterBinderAssociation.CommonParameters)
{
CompiledCommandParameter parameter = parametersInParameter.Parameter;
ParameterSetSpecificMetadata parameterSetData = parameter.GetParameterSetData((uint)(1 << i));
string parameterDescription = this.GetParameterDescription(parameter.Name);
XmlElement xmlElement = this.BuildXmlForParameter(parameter.Name, parameterSetData.IsMandatory, parameterSetData.ValueFromPipeline, parameterSetData.ValueFromPipelineByPropertyName, parameterSetData.IsPositional ? (1 + parameterSetData.Position).ToString((IFormatProvider)CultureInfo.InvariantCulture) : "named", parameter.Type, parameterDescription, true);
element1.AppendChild((XmlNode)xmlElement);
}
}
command.AppendChild((XmlNode)syntax).AppendChild((XmlNode)element1);
}
/// <summary>
///
/// </summary>
/// <param name="psMD"></param>
internal ParameterSetMetadata(ParameterSetSpecificMetadata psMD)
{
Dbg.Assert(null != psMD, "ParameterSetSpecificMetadata cannot be null");
Initialize(psMD);
}
/// <summary>
///
/// </summary>
/// <param name="psMD"></param>
internal void Initialize(ParameterSetSpecificMetadata psMD)
{
_isMandatory = psMD.IsMandatory;
_position = psMD.Position;
_valueFromPipeline = psMD.ValueFromPipeline;
_valueFromPipelineByPropertyName = psMD.ValueFromPipelineByPropertyName;
_valueFromRemainingArguments = psMD.ValueFromRemainingArguments;
_helpMessage = psMD.HelpMessage;
_helpMessageBaseName = psMD.HelpMessageBaseName;
_helpMessageResourceId = psMD.HelpMessageResourceId;
}
private uint NewParameterSetPromptingData(
Dictionary<uint, ParameterSetPromptingData> promptingData,
MergedCompiledCommandParameter parameter,
ParameterSetSpecificMetadata parameterSetMetadata,
uint defaultParameterSet,
bool pipelineInputExpected)
{
uint parameterMandatorySets = 0;
uint parameterSetFlag = parameterSetMetadata.ParameterSetFlag;
if (parameterSetFlag == 0)
{
parameterSetFlag = uint.MaxValue;
}
bool isDefaultSet = (defaultParameterSet != 0) && ((defaultParameterSet & parameterSetFlag) != 0);
bool isMandatory = false;
if (parameterSetMetadata.IsMandatory)
{
parameterMandatorySets |= parameterSetFlag;
isMandatory = true;
}
bool isPipelineable = false;
if (pipelineInputExpected)
{
if (parameterSetMetadata.ValueFromPipeline || parameterSetMetadata.ValueFromPipelineByPropertyName)
{
isPipelineable = true;
}
}
if (isMandatory)
{
ParameterSetPromptingData promptingDataForSet;
if (!promptingData.TryGetValue(parameterSetFlag, out promptingDataForSet))
{
promptingDataForSet = new ParameterSetPromptingData(parameterSetFlag, isDefaultSet);
promptingData.Add(parameterSetFlag, promptingDataForSet);
}
if (isPipelineable)
{
promptingDataForSet.PipelineableMandatoryParameters[parameter] = parameterSetMetadata;
if (parameterSetMetadata.ValueFromPipeline)
{
promptingDataForSet.PipelineableMandatoryByValueParameters[parameter] = parameterSetMetadata;
}
if (parameterSetMetadata.ValueFromPipelineByPropertyName)
{
promptingDataForSet.PipelineableMandatoryByPropertyNameParameters[parameter] = parameterSetMetadata;
}
}
else
{
promptingDataForSet.NonpipelineableMandatoryParameters[parameter] = parameterSetMetadata;
}
}
return parameterMandatorySets;
}
internal ParameterSetMetadata(ParameterSetSpecificMetadata psMD)
{
this.Initialize(psMD);
}
private void ProcessParameterAttribute(string parameterName, ParameterAttribute parameter)
{
if (this._parameterSetData.ContainsKey(parameter.ParameterSetName))
{
System.Management.Automation.MetadataException exception = new System.Management.Automation.MetadataException("ParameterDeclaredInParameterSetMultipleTimes", null, DiscoveryExceptions.ParameterDeclaredInParameterSetMultipleTimes, new object[] { parameterName, parameter.ParameterSetName });
throw exception;
}
if (parameter.ValueFromPipeline || parameter.ValueFromPipelineByPropertyName)
{
this._isPipelineParameterInSomeParameterSet = true;
}
if (parameter.Mandatory)
{
this._isMandatoryInSomeParameterSet = true;
}
ParameterSetSpecificMetadata metadata = new ParameterSetSpecificMetadata(parameter);
this._parameterSetData.Add(parameter.ParameterSetName, metadata);
}
internal ParameterSetMetadata(ParameterSetSpecificMetadata psMD)
{
this.Initialize(psMD);
}
internal XmlDocument BuildXmlFromComments()
{
this.doc = new XmlDocument();
XmlElement element1 = this.doc.CreateElement("command:command", HelpCommentsParser.commandURI);
element1.SetAttribute("xmlns:maml", HelpCommentsParser.mamlURI);
element1.SetAttribute("xmlns:command", HelpCommentsParser.commandURI);
element1.SetAttribute("xmlns:dev", HelpCommentsParser.devURI);
this.doc.AppendChild((XmlNode)element1);
XmlElement element2 = this.doc.CreateElement("command:details", HelpCommentsParser.commandURI);
element1.AppendChild((XmlNode)element2);
XmlElement element3 = this.doc.CreateElement("command:name", HelpCommentsParser.commandURI);
XmlText textNode1 = this.doc.CreateTextNode(this.commandName);
element2.AppendChild((XmlNode)element3).AppendChild((XmlNode)textNode1);
if (!string.IsNullOrEmpty(this.sections.synopsis))
{
XmlElement element4 = this.doc.CreateElement("maml:description", HelpCommentsParser.mamlURI);
XmlElement element5 = this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(this.sections.synopsis);
element2.AppendChild((XmlNode)element4).AppendChild((XmlNode)element5).AppendChild((XmlNode)textNode2);
}
this.DetermineParameterDescriptions();
XmlElement element6 = this.doc.CreateElement("command:syntax", HelpCommentsParser.commandURI);
MergedCommandParameterMetadata parameterMetadata = this.commandMetadata.StaticCommandParameterMetadata;
if (parameterMetadata.ParameterSetCount > 0)
{
for (int i = 0; i < parameterMetadata.ParameterSetCount; ++i)
{
this.BuildSyntaxForParameterSet(element1, element6, parameterMetadata, i);
}
}
else
{
this.BuildSyntaxForParameterSet(element1, element6, parameterMetadata, int.MaxValue);
}
XmlElement element7 = this.doc.CreateElement("command:parameters", HelpCommentsParser.commandURI);
foreach (KeyValuePair <string, MergedCompiledCommandParameter> bindableParameter in parameterMetadata.BindableParameters)
{
MergedCompiledCommandParameter commandParameter = bindableParameter.Value;
if (commandParameter.BinderAssociation != ParameterBinderAssociation.CommonParameters)
{
string key = bindableParameter.Key;
string parameterDescription = this.GetParameterDescription(key);
ParameterSetSpecificMetadata specificMetadata = (ParameterSetSpecificMetadata)null;
bool isMandatory = false;
bool valueFromPipeline = false;
bool valueFromPipelineByPropertyName = false;
string position = "named";
int num = 0;
CompiledCommandParameter parameter = commandParameter.Parameter;
parameter.ParameterSetData.TryGetValue("__AllParameterSets", out specificMetadata);
while (specificMetadata == null && num < 32)
{
specificMetadata = parameter.GetParameterSetData((uint)(1 << num++));
}
if (specificMetadata != null)
{
isMandatory = specificMetadata.IsMandatory;
valueFromPipeline = specificMetadata.ValueFromPipeline;
valueFromPipelineByPropertyName = specificMetadata.ValueFromPipelineByPropertyName;
position = specificMetadata.IsPositional ? (1 + specificMetadata.Position).ToString((IFormatProvider)CultureInfo.InvariantCulture) : "named";
}
XmlElement xmlElement = this.BuildXmlForParameter(key, isMandatory, valueFromPipeline, valueFromPipelineByPropertyName, position, parameter.Type, parameterDescription, false);
element7.AppendChild((XmlNode)xmlElement);
}
}
element1.AppendChild((XmlNode)element7);
if (!string.IsNullOrEmpty(this.sections.description))
{
XmlElement element4 = this.doc.CreateElement("maml:description", HelpCommentsParser.mamlURI);
XmlElement element5 = this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(this.sections.description);
element1.AppendChild((XmlNode)element4).AppendChild((XmlNode)element5).AppendChild((XmlNode)textNode2);
}
if (!string.IsNullOrEmpty(this.sections.notes))
{
XmlElement element4 = this.doc.CreateElement("maml:alertSet", HelpCommentsParser.mamlURI);
XmlElement element5 = this.doc.CreateElement("maml:alert", HelpCommentsParser.mamlURI);
XmlElement element8 = this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(this.sections.notes);
element1.AppendChild((XmlNode)element4).AppendChild((XmlNode)element5).AppendChild((XmlNode)element8).AppendChild((XmlNode)textNode2);
}
if (this.sections.examples.Count > 0)
{
XmlElement element4 = this.doc.CreateElement("command:examples", HelpCommentsParser.commandURI);
int num = 1;
foreach (string example in this.sections.examples)
{
XmlElement element5 = this.doc.CreateElement("command:example", HelpCommentsParser.commandURI);
XmlElement element8 = this.doc.CreateElement("maml:title", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(string.Format((IFormatProvider)CultureInfo.InvariantCulture, "\t\t\t\t-------------------------- {0} {1} --------------------------", (object)ResourceManagerCache.GetResourceString("HelpDisplayStrings", "ExampleUpperCase"), (object)num++));
element5.AppendChild((XmlNode)element8).AppendChild((XmlNode)textNode2);
string prompt_str;
string code_str;
string remarks_str;
this.GetExampleSections(example, out prompt_str, out code_str, out remarks_str);
XmlElement element9 = this.doc.CreateElement("maml:introduction", HelpCommentsParser.mamlURI);
XmlElement element10 = this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI);
XmlText textNode3 = this.doc.CreateTextNode(prompt_str);
element5.AppendChild((XmlNode)element9).AppendChild((XmlNode)element10).AppendChild((XmlNode)textNode3);
XmlElement element11 = this.doc.CreateElement("dev:code", HelpCommentsParser.devURI);
XmlText textNode4 = this.doc.CreateTextNode(code_str);
element5.AppendChild((XmlNode)element11).AppendChild((XmlNode)textNode4);
XmlElement element12 = this.doc.CreateElement("dev:remarks", HelpCommentsParser.devURI);
XmlElement element13 = this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI);
XmlText textNode5 = this.doc.CreateTextNode(remarks_str);
element5.AppendChild((XmlNode)element12).AppendChild((XmlNode)element13).AppendChild((XmlNode)textNode5);
for (int index = 0; index < 4; ++index)
{
element12.AppendChild((XmlNode)this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI));
}
element4.AppendChild((XmlNode)element5);
}
element1.AppendChild((XmlNode)element4);
}
if (this.sections.inputs.Count > 0)
{
XmlElement element4 = this.doc.CreateElement("command:inputTypes", HelpCommentsParser.commandURI);
foreach (string input in this.sections.inputs)
{
XmlElement element5 = this.doc.CreateElement("command:inputType", HelpCommentsParser.commandURI);
XmlElement element8 = this.doc.CreateElement("dev:type", HelpCommentsParser.devURI);
XmlElement element9 = this.doc.CreateElement("maml:name", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(input);
element4.AppendChild((XmlNode)element5).AppendChild((XmlNode)element8).AppendChild((XmlNode)element9).AppendChild((XmlNode)textNode2);
}
element1.AppendChild((XmlNode)element4);
}
IEnumerable enumerable = (IEnumerable)null;
if (this.sections.outputs.Count > 0)
{
enumerable = (IEnumerable)this.sections.outputs;
}
else if (this.scriptBlock.OutputType.Count > 0)
{
enumerable = (IEnumerable)this.scriptBlock.OutputType;
}
if (enumerable != null)
{
XmlElement element4 = this.doc.CreateElement("command:returnValues", HelpCommentsParser.commandURI);
foreach (object obj in enumerable)
{
XmlElement element5 = this.doc.CreateElement("command:returnValue", HelpCommentsParser.commandURI);
XmlElement element8 = this.doc.CreateElement("dev:type", HelpCommentsParser.devURI);
XmlElement element9 = this.doc.CreateElement("maml:name", HelpCommentsParser.mamlURI);
if (!(obj is string text))
{
text = ((PSTypeName)obj).Name;
}
XmlText textNode2 = this.doc.CreateTextNode(text);
element4.AppendChild((XmlNode)element5).AppendChild((XmlNode)element8).AppendChild((XmlNode)element9).AppendChild((XmlNode)textNode2);
}
element1.AppendChild((XmlNode)element4);
}
if (this.sections.links.Count > 0)
{
XmlElement element4 = this.doc.CreateElement("maml:relatedLinks", HelpCommentsParser.mamlURI);
foreach (string link in this.sections.links)
{
XmlElement element5 = this.doc.CreateElement("maml:navigationLink", HelpCommentsParser.mamlURI);
XmlElement element8 = this.doc.CreateElement(Uri.IsWellFormedUriString(Uri.EscapeUriString(link), UriKind.Absolute) ? "maml:uri" : "maml:linkText", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(link);
element4.AppendChild((XmlNode)element5).AppendChild((XmlNode)element8).AppendChild((XmlNode)textNode2);
}
element1.AppendChild((XmlNode)element4);
}
return(this.doc);
}
/// <summary>
/// Extracts the data from the ParameterAttribute and creates the member data as necessary.
/// </summary>
///
/// <param name="parameterName">
/// The name of the parameter.
/// </param>
///
/// <param name="parameter">
/// The instance of the ParameterAttribute to extract the data from.
/// </param>
///
/// <exception cref="MetadataException">
/// If a parameter set name has already been declared on this parameter.
/// </exception>
///
private void ProcessParameterAttribute(
string parameterName,
ParameterAttribute parameter)
{
// If the parameter set name already exists on this parameter and the set name is the default parameter
// set name, it is an error.
if (ParameterSetData.ContainsKey(parameter.ParameterSetName))
{
MetadataException e =
new MetadataException(
"ParameterDeclaredInParameterSetMultipleTimes",
null,
DiscoveryExceptions.ParameterDeclaredInParameterSetMultipleTimes,
parameterName,
parameter.ParameterSetName);
throw e;
}
if (parameter.ValueFromPipeline || parameter.ValueFromPipelineByPropertyName)
{
IsPipelineParameterInSomeParameterSet = true;
}
if (parameter.Mandatory)
{
IsMandatoryInSomeParameterSet = true;
}
// Construct an instance of the parameter set specific data
ParameterSetSpecificMetadata parameterSetSpecificData = new ParameterSetSpecificMetadata(parameter);
ParameterSetData.Add(parameter.ParameterSetName, parameterSetSpecificData);
}
} // EvaluateUnboundPositionalParameters
private static void AddNewPosition(
SortedDictionary<int, Dictionary<MergedCompiledCommandParameter, PositionalCommandParameter>> result,
int positionInParameterSet,
MergedCompiledCommandParameter parameter,
ParameterSetSpecificMetadata parameterSetData)
{
Dictionary<MergedCompiledCommandParameter, PositionalCommandParameter> positionalCommandParameters;
if (result.TryGetValue(positionInParameterSet, out positionalCommandParameters))
{
// Check to see if any of the other parameters in this position are in the same parameter set.
if (ContainsPositionalParameterInSet(positionalCommandParameters, parameter, parameterSetData.ParameterSetFlag))
{
// Multiple parameters were found with the same
// position. This means the parameter set is ambiguous.
// positional parameter could not be resolved
// We throw InvalidOperationException, which the
// caller will catch and throw a more
// appropriate exception.
throw PSTraceSource.NewInvalidOperationException();
}
PositionalCommandParameter positionalCommandParameter;
if (!positionalCommandParameters.TryGetValue(parameter, out positionalCommandParameter))
{
positionalCommandParameter = new PositionalCommandParameter(parameter);
positionalCommandParameters.Add(parameter, positionalCommandParameter);
}
positionalCommandParameter.ParameterSetData.Add(parameterSetData);
}
else
{
Dictionary<MergedCompiledCommandParameter, PositionalCommandParameter> newPositionDictionary =
new Dictionary<MergedCompiledCommandParameter, PositionalCommandParameter>();
PositionalCommandParameter newPositionalParameter = new PositionalCommandParameter(parameter);
newPositionalParameter.ParameterSetData.Add(parameterSetData);
newPositionDictionary.Add(parameter, newPositionalParameter);
result.Add(positionInParameterSet, newPositionDictionary);
}
}
private int NewParameterSetPromptingData(Dictionary<int, ParameterSetPromptingData> promptingData, MergedCompiledCommandParameter parameter, ParameterSetSpecificMetadata parameterSetMetadata, int defaultParameterSet, bool pipelineInputExpected)
{
int num = 0;
int parameterSetFlag = parameterSetMetadata.ParameterSetFlag;
if (parameterSetFlag == 0)
{
parameterSetFlag = int.MaxValue;
}
bool isDefaultSet = (defaultParameterSet != 0) && ((defaultParameterSet & parameterSetFlag) != 0);
bool flag2 = false;
if (parameterSetMetadata.IsMandatory)
{
num |= parameterSetFlag;
flag2 = true;
}
bool flag3 = false;
if (pipelineInputExpected && (parameterSetMetadata.ValueFromPipeline || parameterSetMetadata.ValueFromPipelineByPropertyName))
{
flag3 = true;
}
if (flag2)
{
ParameterSetPromptingData data;
if (!promptingData.TryGetValue(parameterSetFlag, out data))
{
data = new ParameterSetPromptingData(parameterSetFlag, isDefaultSet);
promptingData.Add(parameterSetFlag, data);
}
if (flag3)
{
data.PipelineableMandatoryParameters[parameter] = parameterSetMetadata;
if (parameterSetMetadata.ValueFromPipeline)
{
data.PipelineableMandatoryByValueParameters[parameter] = parameterSetMetadata;
}
if (parameterSetMetadata.ValueFromPipelineByPropertyName)
{
data.PipelineableMandatoryByPropertyNameParameters[parameter] = parameterSetMetadata;
}
return num;
}
data.NonpipelineableMandatoryParameters[parameter] = parameterSetMetadata;
}
return num;
}
private static void AddNewPosition(SortedDictionary <int, Dictionary <MergedCompiledCommandParameter, PositionalCommandParameter> > result, int positionInParameterSet, MergedCompiledCommandParameter parameter, ParameterSetSpecificMetadata parameterSetData)
{
if (result.ContainsKey(positionInParameterSet))
{
Dictionary <MergedCompiledCommandParameter, PositionalCommandParameter> positionalCommandParameters = result[positionInParameterSet];
if (ContainsPositionalParameterInSet(positionalCommandParameters, parameter, parameterSetData.ParameterSetFlag))
{
throw PSTraceSource.NewInvalidOperationException();
}
if (positionalCommandParameters.ContainsKey(parameter))
{
positionalCommandParameters[parameter].ParameterSetData.Add(parameterSetData);
}
else
{
PositionalCommandParameter parameter2 = new PositionalCommandParameter(parameter);
parameter2.ParameterSetData.Add(parameterSetData);
positionalCommandParameters.Add(parameter, parameter2);
}
}
else
{
Dictionary <MergedCompiledCommandParameter, PositionalCommandParameter> dictionary2 = new Dictionary <MergedCompiledCommandParameter, PositionalCommandParameter>();
PositionalCommandParameter parameter3 = new PositionalCommandParameter(parameter)
{
ParameterSetData = { parameterSetData }
};
dictionary2.Add(parameter, parameter3);
result.Add(positionInParameterSet, dictionary2);
}
}