/// <summary>
/// Get suggestion text from suggestion scriptblock with arguments.
/// </summary>
private static string GetSuggestionText(Object suggestion, object[] suggestionArgs, PSModuleInfo invocationModule)
{
if (suggestion is ScriptBlock)
{
ScriptBlock suggestionScript = (ScriptBlock)suggestion;
object result = null;
try
{
result = invocationModule.Invoke(suggestionScript, suggestionArgs);
}
catch (Exception)
{
// Catch-all OK. This is a third-party call-out.
return(String.Empty);
}
return((string)LanguagePrimitives.ConvertTo(result, typeof(string), CultureInfo.CurrentCulture));
}
else
{
return((string)LanguagePrimitives.ConvertTo(suggestion, typeof(string), CultureInfo.CurrentCulture));
}
}
private void HandleRunspaceCreated(object sender, RunspaceCreatedEventArgs args)
{
try
{
string folderPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
args.Runspace.ExecutionContext.EngineSessionState.SetLocation(folderPath);
}
catch (ArgumentException ex)
{
}
catch (ProviderNotFoundException ex)
{
}
catch (DriveNotFoundException ex)
{
}
catch (ProviderInvocationException ex)
{
}
Command command = (Command)null;
if (!string.IsNullOrEmpty(this.configData.StartupScript))
{
command = new Command(this.configData.StartupScript, false, false);
}
else if (!string.IsNullOrEmpty(this.configData.InitializationScriptForOutOfProcessRunspace))
{
command = new Command(this.configData.InitializationScriptForOutOfProcessRunspace, true, false);
}
if (command == null)
{
return;
}
HostInfo hostInfo = this.remoteHost.HostInfo;
command.MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output);
PowerShell powershell = PowerShell.Create();
powershell.AddCommand(command).AddCommand("out-default");
IAsyncResult asyncResult = new ServerPowerShellDriver(powershell, (PowerShell)null, true, Guid.Empty, this.InstanceId, this, args.Runspace.ApartmentState, hostInfo, RemoteStreamOptions.AddInvocationInfo, false, args.Runspace).Start();
powershell.EndInvoke(asyncResult);
ArrayList dollarErrorVariable = (ArrayList)powershell.Runspace.GetExecutionContext.DollarErrorVariable;
if (dollarErrorVariable.Count > 0)
{
string str = (dollarErrorVariable[0] as ErrorRecord).ToString();
throw ServerRunspacePoolDriver.tracer.NewInvalidOperationException("RemotingErrorIdStrings", PSRemotingErrorId.StartupScriptThrewTerminatingError.ToString(), (object)str);
}
if (this.localRunspacePool.RunspacePoolStateInfo.State != RunspacePoolState.Opening)
{
return;
}
object valueToConvert = args.Runspace.SessionStateProxy.PSVariable.GetValue("global:PSApplicationPrivateData");
if (valueToConvert == null)
{
return;
}
this.applicationPrivateData = (PSPrimitiveDictionary)LanguagePrimitives.ConvertTo(valueToConvert, typeof(PSPrimitiveDictionary), true, (IFormatProvider)CultureInfo.InvariantCulture, (TypeTable)null);
}
private static T ConvertPropertyValueTo <T>(string propertyName, object propertyValue)
{
using (RemotingDecoder._trace.TraceMethod())
{
if (propertyName == null)
{
throw RemotingDecoder._trace.NewArgumentNullException(nameof(propertyName));
}
if (typeof(T).IsEnum)
{
if (propertyValue is string)
{
try
{
return((T)Enum.Parse(typeof(T), (string)propertyValue, true));
}
catch (ArgumentException ex)
{
throw new PSRemotingDataStructureException(PSRemotingErrorId.CantCastPropertyToExpectedType, new object[3]
{
(object)propertyName,
(object)typeof(T).FullName,
(object)propertyValue.GetType().FullName
});
}
}
else
{
try
{
Type underlyingType = Enum.GetUnderlyingType(typeof(T));
return((T)LanguagePrimitives.ConvertTo(propertyValue, underlyingType, (IFormatProvider)CultureInfo.InvariantCulture));
}
catch (InvalidCastException ex)
{
throw new PSRemotingDataStructureException(PSRemotingErrorId.CantCastPropertyToExpectedType, new object[3]
{
(object)propertyName,
(object)typeof(T).FullName,
(object)propertyValue.GetType().FullName
});
}
}
}
else
{
if (typeof(T).Equals(typeof(PSObject)))
{
return(propertyValue == null ? default(T) : (T)PSObject.AsPSObject(propertyValue));
}
switch (propertyValue)
{
case null:
if (!typeof(T).IsValueType)
{
return(default(T));
}
if (typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
return(default(T));
}
throw new PSRemotingDataStructureException(PSRemotingErrorId.CantCastPropertyToExpectedType, new object[3]
{
(object)propertyName,
(object)typeof(T).FullName,
propertyValue != null ? (object)propertyValue.GetType().FullName : (object)"null"
});
case T obj:
return(obj);
case PSObject _:
PSObject psObject = (PSObject)propertyValue;
return(RemotingDecoder.ConvertPropertyValueTo <T>(propertyName, psObject.BaseObject));
case Hashtable _:
if (typeof(T).Equals(typeof(PSPrimitiveDictionary)))
{
try
{
return((T) new PSPrimitiveDictionary((Hashtable)propertyValue));
}
catch (ArgumentException ex)
{
throw new PSRemotingDataStructureException(PSRemotingErrorId.CantCastPropertyToExpectedType, new object[3]
{
(object)propertyName,
(object)typeof(T).FullName,
propertyValue != null ? (object)propertyValue.GetType().FullName : (object)"null"
});
}
}
else
{
break;
}
}
throw new PSRemotingDataStructureException(PSRemotingErrorId.CantCastPropertyToExpectedType, new object[3]
{
(object)propertyName,
(object)typeof(T).FullName,
(object)propertyValue.GetType().FullName
});
}
}
}
internal static Uri GetUriFromCommandPSObject(PSObject commandFullHelp)
{
// this object knows Maml format...
// So retrieve Uri information as per the format..
if ((commandFullHelp == null) ||
(commandFullHelp.Properties["relatedLinks"] == null) ||
(commandFullHelp.Properties["relatedLinks"].Value == null))
{
// return the default..
return(null);
}
PSObject relatedLinks = PSObject.AsPSObject(commandFullHelp.Properties["relatedLinks"].Value);
if (relatedLinks.Properties["navigationLink"] == null)
{
return(null);
}
object[] navigationLinks = (object[])LanguagePrimitives.ConvertTo(
relatedLinks.Properties["navigationLink"].Value,
typeof(object[]),
CultureInfo.InvariantCulture);
foreach (object navigationLinkAsObject in navigationLinks)
{
if (navigationLinkAsObject == null)
{
continue;
}
PSObject navigationLink = PSObject.AsPSObject(navigationLinkAsObject);
PSNoteProperty uriNP = navigationLink.Properties["uri"] as PSNoteProperty;
if (null != uriNP)
{
string uriString = string.Empty;
LanguagePrimitives.TryConvertTo <string>(uriNP.Value, CultureInfo.InvariantCulture, out uriString);
if (!string.IsNullOrEmpty(uriString))
{
if (!System.Uri.IsWellFormedUriString(uriString, UriKind.RelativeOrAbsolute))
{
// WinBlue: 545315 Online help links are broken with localized help
// Example: https://go.microsoft.com/fwlink/?LinkID=113324 (möglicherwei se auf Englisch)
// Split the string based on <s> (space). We decided to go with this approach as
// UX localization authors use spaces. Correctly extracting only the wellformed URI
// is out-of-scope for this fix.
string[] tempUriSplitArray = uriString.Split(Utils.Separators.Space);
uriString = tempUriSplitArray[0];
}
try
{
return(new System.Uri(uriString));
// return only the first Uri (ignore other uris)
}
catch (UriFormatException)
{
throw PSTraceSource.NewInvalidOperationException(HelpErrors.InvalidURI, uriString);
}
}
}
}
return(null);
}
public string ToString(string format, IFormatProvider formatProvider)
{
return((string)LanguagePrimitives.ConvertTo(ImmediateBaseObject, typeof(string), formatProvider));
}
internal static ArrayList GetSuggestion(HistoryInfo lastHistory, Object lastError, ArrayList errorList)
{
ArrayList returnSuggestions = new ArrayList();
PSModuleInfo invocationModule = new PSModuleInfo(true);
invocationModule.SessionState.PSVariable.Set("lastHistory", lastHistory);
invocationModule.SessionState.PSVariable.Set("lastError", lastError);
int initialErrorCount = 0;
// Go through all of the suggestions
foreach (Hashtable suggestion in s_suggestions)
{
initialErrorCount = errorList.Count;
// Make sure the rule is enabled
if (!LanguagePrimitives.IsTrue(suggestion["Enabled"]))
{
continue;
}
SuggestionMatchType matchType = (SuggestionMatchType)LanguagePrimitives.ConvertTo(
suggestion["MatchType"],
typeof(SuggestionMatchType),
CultureInfo.InvariantCulture);
// If this is a dynamic match, evaluate the ScriptBlock
if (matchType == SuggestionMatchType.Dynamic)
{
object result = null;
ScriptBlock evaluator = suggestion["Rule"] as ScriptBlock;
if (evaluator == null)
{
suggestion["Enabled"] = false;
throw new ArgumentException(
SuggestionStrings.RuleMustBeScriptBlock, "Rule");
}
try
{
result = invocationModule.Invoke(evaluator, null);
}
catch (Exception)
{
// Catch-all OK. This is a third-party call-out.
suggestion["Enabled"] = false;
continue;
}
// If it returned results, evaluate its suggestion
if (LanguagePrimitives.IsTrue(result))
{
string suggestionText = GetSuggestionText(suggestion["Suggestion"], (object[])suggestion["SuggestionArgs"], invocationModule);
if (!String.IsNullOrEmpty(suggestionText))
{
string returnString = String.Format(
CultureInfo.CurrentCulture,
"Suggestion [{0},{1}]: {2}",
(int)suggestion["Id"],
(string)suggestion["Category"],
suggestionText);
returnSuggestions.Add(returnString);
}
}
}
else
{
string matchText = String.Empty;
// Otherwise, this is a Regex match against the
// command or error
if (matchType == SuggestionMatchType.Command)
{
matchText = lastHistory.CommandLine;
}
else if (matchType == SuggestionMatchType.Error)
{
if (lastError != null)
{
Exception lastException = lastError as Exception;
if (lastException != null)
{
matchText = lastException.Message;
}
else
{
matchText = lastError.ToString();
}
}
}
else
{
suggestion["Enabled"] = false;
throw new ArgumentException(
SuggestionStrings.InvalidMatchType,
"MatchType");
}
// If the text matches, evaluate the suggestion
if (Regex.IsMatch(matchText, (string)suggestion["Rule"], RegexOptions.IgnoreCase))
{
string suggestionText = GetSuggestionText(suggestion["Suggestion"], (object[])suggestion["SuggestionArgs"], invocationModule);
if (!String.IsNullOrEmpty(suggestionText))
{
string returnString = String.Format(
CultureInfo.CurrentCulture,
"Suggestion [{0},{1}]: {2}",
(int)suggestion["Id"],
(string)suggestion["Category"],
suggestionText);
returnSuggestions.Add(returnString);
}
}
}
// If the rule generated an error, disable it
if (errorList.Count != initialErrorCount)
{
suggestion["Enabled"] = false;
}
}
return(returnSuggestions);
}
private static ConcurrentDictionary <string, CommandTypes> AnalyzeManifestModule(string modulePath, ExecutionContext context, DateTime lastWriteTime, bool etwEnabled)
{
ConcurrentDictionary <string, CommandTypes> result = null;
try
{
var moduleManifestProperties = PsUtils.GetModuleManifestProperties(modulePath, PsUtils.FastModuleManifestAnalysisPropertyNames);
if (moduleManifestProperties != null)
{
Version version;
if (ModuleUtils.IsModuleInVersionSubdirectory(modulePath, out version))
{
var versionInManifest = LanguagePrimitives.ConvertTo <Version>(moduleManifestProperties["ModuleVersion"]);
if (version != versionInManifest)
{
ModuleIntrinsics.Tracer.WriteLine("ModuleVersion in manifest does not match versioned module directory, skipping module: {0}", modulePath);
return(null);
}
}
result = new ConcurrentDictionary <string, CommandTypes>(3, moduleManifestProperties.Count, StringComparer.OrdinalIgnoreCase);
var sawWildcard = false;
var hadCmdlets = AddPsd1EntryToResult(result, moduleManifestProperties["CmdletsToExport"], CommandTypes.Cmdlet, ref sawWildcard);
var hadFunctions = AddPsd1EntryToResult(result, moduleManifestProperties["FunctionsToExport"], CommandTypes.Function, ref sawWildcard);
var hadAliases = AddPsd1EntryToResult(result, moduleManifestProperties["AliasesToExport"], CommandTypes.Alias, ref sawWildcard);
var analysisSucceeded = hadCmdlets && hadFunctions && hadAliases;
if (!analysisSucceeded && !sawWildcard && (hadCmdlets || hadFunctions))
{
// If we're missing CmdletsToExport, that might still be OK, but only if we have a script module.
// Likewise, if we're missing FunctionsToExport, that might be OK, but only if we have a binary module.
analysisSucceeded = !CheckModulesTypesInManifestAgainstExportedCommands(moduleManifestProperties, hadCmdlets, hadFunctions, hadAliases);
}
if (analysisSucceeded)
{
var moduleCacheEntry = new ModuleCacheEntry
{
ModulePath = modulePath,
LastWriteTime = lastWriteTime,
Commands = result,
TypesAnalyzed = false,
Types = new ConcurrentDictionary <string, TypeAttributes>(1, 8, StringComparer.OrdinalIgnoreCase)
};
s_cacheData.Entries[modulePath] = moduleCacheEntry;
}
else
{
result = null;
}
}
}
catch (Exception e)
{
if (etwEnabled)
{
CommandDiscoveryEventSource.Log.ModuleManifestAnalysisException(modulePath, e.Message);
}
// Ignore the errors, proceed with the usual module analysis
ModuleIntrinsics.Tracer.WriteLine("Exception on fast-path analysis of module {0}", modulePath);
}
if (etwEnabled)
{
CommandDiscoveryEventSource.Log.ModuleManifestAnalysisResult(modulePath, result != null);
}
return(result ?? AnalyzeTheOldWay(modulePath, context, lastWriteTime));
}
protected override void SetValueImpl(int index, object value)
{
switch (index)
{
case 0:
base.Item000 = LanguagePrimitives.ConvertTo <T0>(value);
return;
case 1:
base.Item001 = LanguagePrimitives.ConvertTo <T1>(value);
return;
case 2:
base.Item002 = LanguagePrimitives.ConvertTo <T2>(value);
return;
case 3:
base.Item003 = LanguagePrimitives.ConvertTo <T3>(value);
return;
case 4:
base.Item004 = LanguagePrimitives.ConvertTo <T4>(value);
return;
case 5:
base.Item005 = LanguagePrimitives.ConvertTo <T5>(value);
return;
case 6:
base.Item006 = LanguagePrimitives.ConvertTo <T6>(value);
return;
case 7:
base.Item007 = LanguagePrimitives.ConvertTo <T7>(value);
return;
case 8:
base.Item008 = LanguagePrimitives.ConvertTo <T8>(value);
return;
case 9:
base.Item009 = LanguagePrimitives.ConvertTo <T9>(value);
return;
case 10:
base.Item010 = LanguagePrimitives.ConvertTo <T10>(value);
return;
case 11:
base.Item011 = LanguagePrimitives.ConvertTo <T11>(value);
return;
case 12:
base.Item012 = LanguagePrimitives.ConvertTo <T12>(value);
return;
case 13:
base.Item013 = LanguagePrimitives.ConvertTo <T13>(value);
return;
case 14:
base.Item014 = LanguagePrimitives.ConvertTo <T14>(value);
return;
case 15:
base.Item015 = LanguagePrimitives.ConvertTo <T15>(value);
return;
case 0x10:
this.Item016 = LanguagePrimitives.ConvertTo <T16>(value);
return;
case 0x11:
this.Item017 = LanguagePrimitives.ConvertTo <T17>(value);
return;
case 0x12:
this.Item018 = LanguagePrimitives.ConvertTo <T18>(value);
return;
case 0x13:
this.Item019 = LanguagePrimitives.ConvertTo <T19>(value);
return;
case 20:
this.Item020 = LanguagePrimitives.ConvertTo <T20>(value);
return;
case 0x15:
this.Item021 = LanguagePrimitives.ConvertTo <T21>(value);
return;
case 0x16:
this.Item022 = LanguagePrimitives.ConvertTo <T22>(value);
return;
case 0x17:
this.Item023 = LanguagePrimitives.ConvertTo <T23>(value);
return;
case 0x18:
this.Item024 = LanguagePrimitives.ConvertTo <T24>(value);
return;
case 0x19:
this.Item025 = LanguagePrimitives.ConvertTo <T25>(value);
return;
case 0x1a:
this.Item026 = LanguagePrimitives.ConvertTo <T26>(value);
return;
case 0x1b:
this.Item027 = LanguagePrimitives.ConvertTo <T27>(value);
return;
case 0x1c:
this.Item028 = LanguagePrimitives.ConvertTo <T28>(value);
return;
case 0x1d:
this.Item029 = LanguagePrimitives.ConvertTo <T29>(value);
return;
case 30:
this.Item030 = LanguagePrimitives.ConvertTo <T30>(value);
return;
case 0x1f:
this.Item031 = LanguagePrimitives.ConvertTo <T31>(value);
return;
}
throw new ArgumentOutOfRangeException("index");
}
private void ReadXml()
{
try
{
Deserializer deserializer = new Deserializer((XmlReader) new XmlTextReader((TextReader)this.streamReader));
while (!deserializer.Done())
{
string streamName;
object obj = deserializer.Deserialize(out streamName);
MinishellStream stream = MinishellStream.Unknown;
if (streamName != null)
{
stream = StringToMinishellStreamConverter.ToMinishellStream(streamName);
}
if (stream == MinishellStream.Unknown)
{
stream = this.isOutput ? MinishellStream.Output : MinishellStream.Error;
}
if (stream == MinishellStream.Output || obj != null)
{
switch (stream)
{
case MinishellStream.Error:
if (obj is PSObject)
{
obj = (object)ErrorRecord.FromPSObjectForRemoting(PSObject.AsPSObject(obj));
break;
}
string message;
try
{
message = (string)LanguagePrimitives.ConvertTo(obj, typeof(string), (IFormatProvider)CultureInfo.InvariantCulture);
}
catch (PSInvalidCastException ex)
{
ProcessStreamReader.tracer.TraceException((Exception)ex);
continue;
}
obj = (object)new ErrorRecord((Exception) new RemoteException(message), "NativeCommandError", ErrorCategory.NotSpecified, (object)message);
break;
case MinishellStream.Verbose:
case MinishellStream.Warning:
case MinishellStream.Debug:
try
{
obj = LanguagePrimitives.ConvertTo(obj, typeof(string), (IFormatProvider)CultureInfo.InvariantCulture);
break;
}
catch (PSInvalidCastException ex)
{
ProcessStreamReader.tracer.TraceException((Exception)ex);
continue;
}
}
this.AddObjectToWriter(obj, stream);
}
}
}
catch (XmlException ex)
{
ProcessStreamReader.tracer.TraceException((Exception)ex);
this.AddObjectToWriter((object)new ErrorRecord((Exception) new XmlException(string.Format((IFormatProvider)null, ResourceManagerCache.GetResourceString("NativeCP", "CliXmlError"), (object)(MinishellStream)(this.isOutput ? 0 : 1), (object)this.processPath, (object)ex.Message), (Exception)ex), "ProcessStreamReader_CliXmlError", ErrorCategory.SyntaxError, (object)this.processPath), MinishellStream.Error);
}
}
private static object ConvertToNumber(string str, Tokenizer tokenizer)
{
bool flag1 = false;
bool flag2 = false;
bool flag3 = false;
bool flag4 = false;
long num = 1;
str = NumberTokenReader.ConvertDash(str);
if (str.IndexOf("0x", 0, StringComparison.OrdinalIgnoreCase) >= 0)
{
flag1 = true;
}
if (!flag1 && (str.IndexOf('.', 0) >= 0 || str.IndexOf("e", 0, StringComparison.OrdinalIgnoreCase) >= 0))
{
flag4 = true;
}
if (NumberTokenReader.IsMultiplier(str, str.Length - 2))
{
switch (char.ToUpperInvariant(str[str.Length - 2]))
{
case 'G':
num = 1073741824L;
str = str.Substring(0, str.Length - 2);
break;
case 'K':
num = 1024L;
str = str.Substring(0, str.Length - 2);
break;
case 'M':
num = 1048576L;
str = str.Substring(0, str.Length - 2);
break;
case 'P':
num = 1125899906842624L;
str = str.Substring(0, str.Length - 2);
break;
case 'T':
num = 1099511627776L;
str = str.Substring(0, str.Length - 2);
break;
}
}
char upperInvariant = char.ToUpperInvariant(str[str.Length - 1]);
if (upperInvariant == 'L')
{
flag2 = true;
str = str.Substring(0, str.Length - 1);
}
else if (!flag1 && upperInvariant == 'D')
{
flag3 = true;
str = str.Substring(0, str.Length - 1);
}
Exception innerException;
try
{
if (flag3)
{
return((object)(Decimal.Parse(str, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, (IFormatProvider)NumberFormatInfo.InvariantInfo) * (Decimal)num));
}
if (flag2)
{
return((object)checked ((long)LanguagePrimitives.ConvertTo((object)str, typeof(long), (IFormatProvider)NumberFormatInfo.InvariantInfo) * num));
}
if (flag4)
{
return((object)(double.Parse(str, (IFormatProvider)NumberFormatInfo.InvariantInfo) * (double)num));
}
try
{
return((object)checked ((int)LanguagePrimitives.ConvertTo((object)str, typeof(int), (IFormatProvider)NumberFormatInfo.InvariantInfo) * (int)num));
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
}
try
{
return((object)checked ((long)LanguagePrimitives.ConvertTo((object)str, typeof(long), (IFormatProvider)NumberFormatInfo.InvariantInfo) * num));
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
}
try
{
return((object)((Decimal)LanguagePrimitives.ConvertTo((object)str, typeof(Decimal), (IFormatProvider)NumberFormatInfo.InvariantInfo) * (Decimal)num));
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
}
return((object)((double)LanguagePrimitives.ConvertTo((object)str, typeof(double), (IFormatProvider)NumberFormatInfo.InvariantInfo) * (double)num));
}
catch (OverflowException ex)
{
innerException = (Exception)ex;
}
catch (FormatException ex)
{
innerException = (Exception)ex;
}
catch (PSInvalidCastException ex)
{
innerException = (Exception)ex;
}
if (innerException != null)
{
if (tokenizer != null)
{
tokenizer.Parser.ReportExceptionWithInnerException((object)str, typeof(ParseException), tokenizer.PositionToken(), "BadNumericConstant", innerException, (object)innerException.Message);
}
else
{
throw InterpreterError.NewInterpreterExceptionWithInnerException((object)str, typeof(RuntimeException), (Token)null, "BadNumericConstant", innerException, (object)innerException.Message);
}
}
return((object)null);
}
private static T ConvertPropertyValueTo <T>(string propertyName, object propertyValue)
{
if (propertyName == null)
{
throw PSTraceSource.NewArgumentNullException("propertyName");
}
if (typeof(T).IsEnum)
{
if (propertyValue is string)
{
try
{
string str = (string)propertyValue;
return((T)Enum.Parse(typeof(T), str, true));
}
catch (ArgumentException)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.CantCastPropertyToExpectedType, new object[] { propertyName, typeof(T).FullName, propertyValue.GetType().FullName });
}
}
try
{
Type underlyingType = Enum.GetUnderlyingType(typeof(T));
return((T)LanguagePrimitives.ConvertTo(propertyValue, underlyingType, CultureInfo.InvariantCulture));
}
catch (InvalidCastException)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.CantCastPropertyToExpectedType, new object[] { propertyName, typeof(T).FullName, propertyValue.GetType().FullName });
}
}
if (typeof(T).Equals(typeof(PSObject)))
{
if (propertyValue == null)
{
return(default(T));
}
return((T)Convert.ChangeType(PSObject.AsPSObject(propertyValue), typeof(T)));
}
if (propertyValue == null)
{
if (typeof(T).IsValueType && (!typeof(T).IsGenericType || !typeof(T).GetGenericTypeDefinition().Equals(typeof(Nullable <>))))
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.CantCastPropertyToExpectedType, new object[] { propertyName, typeof(T).FullName, (propertyValue != null) ? propertyValue.GetType().FullName : "null" });
}
return(default(T));
}
if (propertyValue is T)
{
return((T)propertyValue);
}
if (propertyValue is PSObject)
{
PSObject obj3 = (PSObject)propertyValue;
return(ConvertPropertyValueTo <T>(propertyName, obj3.BaseObject));
}
if ((propertyValue is Hashtable) && typeof(T).Equals(typeof(PSPrimitiveDictionary)))
{
try
{
return((T)Convert.ChangeType(new PSPrimitiveDictionary((Hashtable)propertyValue), typeof(T)));
}
catch (ArgumentException)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.CantCastPropertyToExpectedType, new object[] { propertyName, typeof(T).FullName, (propertyValue != null) ? propertyValue.GetType().FullName : "null" });
}
}
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.CantCastPropertyToExpectedType, new object[] { propertyName, typeof(T).FullName, propertyValue.GetType().FullName });
}
protected override void SetValueImpl(int index, object value)
{
switch (index)
{
case 0:
base.Item000 = LanguagePrimitives.ConvertTo <T0>(value);
return;
case 1:
base.Item001 = LanguagePrimitives.ConvertTo <T1>(value);
return;
case 2:
base.Item002 = LanguagePrimitives.ConvertTo <T2>(value);
return;
case 3:
base.Item003 = LanguagePrimitives.ConvertTo <T3>(value);
return;
case 4:
base.Item004 = LanguagePrimitives.ConvertTo <T4>(value);
return;
case 5:
base.Item005 = LanguagePrimitives.ConvertTo <T5>(value);
return;
case 6:
base.Item006 = LanguagePrimitives.ConvertTo <T6>(value);
return;
case 7:
base.Item007 = LanguagePrimitives.ConvertTo <T7>(value);
return;
case 8:
base.Item008 = LanguagePrimitives.ConvertTo <T8>(value);
return;
case 9:
base.Item009 = LanguagePrimitives.ConvertTo <T9>(value);
return;
case 10:
base.Item010 = LanguagePrimitives.ConvertTo <T10>(value);
return;
case 11:
base.Item011 = LanguagePrimitives.ConvertTo <T11>(value);
return;
case 12:
base.Item012 = LanguagePrimitives.ConvertTo <T12>(value);
return;
case 13:
base.Item013 = LanguagePrimitives.ConvertTo <T13>(value);
return;
case 14:
base.Item014 = LanguagePrimitives.ConvertTo <T14>(value);
return;
case 15:
base.Item015 = LanguagePrimitives.ConvertTo <T15>(value);
return;
case 0x10:
base.Item016 = LanguagePrimitives.ConvertTo <T16>(value);
return;
case 0x11:
base.Item017 = LanguagePrimitives.ConvertTo <T17>(value);
return;
case 0x12:
base.Item018 = LanguagePrimitives.ConvertTo <T18>(value);
return;
case 0x13:
base.Item019 = LanguagePrimitives.ConvertTo <T19>(value);
return;
case 20:
base.Item020 = LanguagePrimitives.ConvertTo <T20>(value);
return;
case 0x15:
base.Item021 = LanguagePrimitives.ConvertTo <T21>(value);
return;
case 0x16:
base.Item022 = LanguagePrimitives.ConvertTo <T22>(value);
return;
case 0x17:
base.Item023 = LanguagePrimitives.ConvertTo <T23>(value);
return;
case 0x18:
base.Item024 = LanguagePrimitives.ConvertTo <T24>(value);
return;
case 0x19:
base.Item025 = LanguagePrimitives.ConvertTo <T25>(value);
return;
case 0x1a:
base.Item026 = LanguagePrimitives.ConvertTo <T26>(value);
return;
case 0x1b:
base.Item027 = LanguagePrimitives.ConvertTo <T27>(value);
return;
case 0x1c:
base.Item028 = LanguagePrimitives.ConvertTo <T28>(value);
return;
case 0x1d:
base.Item029 = LanguagePrimitives.ConvertTo <T29>(value);
return;
case 30:
base.Item030 = LanguagePrimitives.ConvertTo <T30>(value);
return;
case 0x1f:
base.Item031 = LanguagePrimitives.ConvertTo <T31>(value);
return;
case 0x20:
this.Item032 = LanguagePrimitives.ConvertTo <T32>(value);
return;
case 0x21:
this.Item033 = LanguagePrimitives.ConvertTo <T33>(value);
return;
case 0x22:
this.Item034 = LanguagePrimitives.ConvertTo <T34>(value);
return;
case 0x23:
this.Item035 = LanguagePrimitives.ConvertTo <T35>(value);
return;
case 0x24:
this.Item036 = LanguagePrimitives.ConvertTo <T36>(value);
return;
case 0x25:
this.Item037 = LanguagePrimitives.ConvertTo <T37>(value);
return;
case 0x26:
this.Item038 = LanguagePrimitives.ConvertTo <T38>(value);
return;
case 0x27:
this.Item039 = LanguagePrimitives.ConvertTo <T39>(value);
return;
case 40:
this.Item040 = LanguagePrimitives.ConvertTo <T40>(value);
return;
case 0x29:
this.Item041 = LanguagePrimitives.ConvertTo <T41>(value);
return;
case 0x2a:
this.Item042 = LanguagePrimitives.ConvertTo <T42>(value);
return;
case 0x2b:
this.Item043 = LanguagePrimitives.ConvertTo <T43>(value);
return;
case 0x2c:
this.Item044 = LanguagePrimitives.ConvertTo <T44>(value);
return;
case 0x2d:
this.Item045 = LanguagePrimitives.ConvertTo <T45>(value);
return;
case 0x2e:
this.Item046 = LanguagePrimitives.ConvertTo <T46>(value);
return;
case 0x2f:
this.Item047 = LanguagePrimitives.ConvertTo <T47>(value);
return;
case 0x30:
this.Item048 = LanguagePrimitives.ConvertTo <T48>(value);
return;
case 0x31:
this.Item049 = LanguagePrimitives.ConvertTo <T49>(value);
return;
case 50:
this.Item050 = LanguagePrimitives.ConvertTo <T50>(value);
return;
case 0x33:
this.Item051 = LanguagePrimitives.ConvertTo <T51>(value);
return;
case 0x34:
this.Item052 = LanguagePrimitives.ConvertTo <T52>(value);
return;
case 0x35:
this.Item053 = LanguagePrimitives.ConvertTo <T53>(value);
return;
case 0x36:
this.Item054 = LanguagePrimitives.ConvertTo <T54>(value);
return;
case 0x37:
this.Item055 = LanguagePrimitives.ConvertTo <T55>(value);
return;
case 0x38:
this.Item056 = LanguagePrimitives.ConvertTo <T56>(value);
return;
case 0x39:
this.Item057 = LanguagePrimitives.ConvertTo <T57>(value);
return;
case 0x3a:
this.Item058 = LanguagePrimitives.ConvertTo <T58>(value);
return;
case 0x3b:
this.Item059 = LanguagePrimitives.ConvertTo <T59>(value);
return;
case 60:
this.Item060 = LanguagePrimitives.ConvertTo <T60>(value);
return;
case 0x3d:
this.Item061 = LanguagePrimitives.ConvertTo <T61>(value);
return;
case 0x3e:
this.Item062 = LanguagePrimitives.ConvertTo <T62>(value);
return;
case 0x3f:
this.Item063 = LanguagePrimitives.ConvertTo <T63>(value);
return;
}
throw new ArgumentOutOfRangeException("index");
}
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);
}
protected override void SetValueImpl(int index, object value)
{
switch (index)
{
case 0:
base.Item000 = LanguagePrimitives.ConvertTo <T0>(value);
return;
case 1:
base.Item001 = LanguagePrimitives.ConvertTo <T1>(value);
return;
case 2:
base.Item002 = LanguagePrimitives.ConvertTo <T2>(value);
return;
case 3:
base.Item003 = LanguagePrimitives.ConvertTo <T3>(value);
return;
case 4:
base.Item004 = LanguagePrimitives.ConvertTo <T4>(value);
return;
case 5:
base.Item005 = LanguagePrimitives.ConvertTo <T5>(value);
return;
case 6:
base.Item006 = LanguagePrimitives.ConvertTo <T6>(value);
return;
case 7:
base.Item007 = LanguagePrimitives.ConvertTo <T7>(value);
return;
case 8:
this.Item008 = LanguagePrimitives.ConvertTo <T8>(value);
return;
case 9:
this.Item009 = LanguagePrimitives.ConvertTo <T9>(value);
return;
case 10:
this.Item010 = LanguagePrimitives.ConvertTo <T10>(value);
return;
case 11:
this.Item011 = LanguagePrimitives.ConvertTo <T11>(value);
return;
case 12:
this.Item012 = LanguagePrimitives.ConvertTo <T12>(value);
return;
case 13:
this.Item013 = LanguagePrimitives.ConvertTo <T13>(value);
return;
case 14:
this.Item014 = LanguagePrimitives.ConvertTo <T14>(value);
return;
case 15:
this.Item015 = LanguagePrimitives.ConvertTo <T15>(value);
return;
}
throw new ArgumentOutOfRangeException("index");
}
internal void AppendDollarError(object obj)
{
ErrorRecord record = obj as ErrorRecord;
if ((record != null) || (obj is Exception))
{
ArrayList dollarErrorVariable = this.DollarErrorVariable as ArrayList;
if (dollarErrorVariable != null)
{
if (dollarErrorVariable.Count > 0)
{
if (dollarErrorVariable[0] == obj)
{
return;
}
ErrorRecord record2 = dollarErrorVariable[0] as ErrorRecord;
if (((record2 != null) && (record != null)) && (record2.Exception == record.Exception))
{
return;
}
}
object fastValue = this.EngineSessionState.CurrentScope.ErrorCapacity.FastValue;
if (fastValue != null)
{
try
{
fastValue = LanguagePrimitives.ConvertTo(fastValue, typeof(int), CultureInfo.InvariantCulture);
}
catch (PSInvalidCastException)
{
}
catch (OverflowException)
{
}
catch (Exception)
{
throw;
}
}
int num = (fastValue is int) ? ((int)fastValue) : 0x100;
if (0 > num)
{
num = 0;
}
else if (0x8000 < num)
{
num = 0x8000;
}
if (0 >= num)
{
dollarErrorVariable.Clear();
}
else
{
int count = dollarErrorVariable.Count - (num - 1);
if (0 < count)
{
dollarErrorVariable.RemoveRange(num - 1, count);
}
dollarErrorVariable.Insert(0, obj);
}
}
}
}
internal static ArrayList GetSuggestion(
HistoryInfo lastHistory,
object lastError,
ArrayList errorList)
{
ArrayList arrayList = new ArrayList();
PSModuleInfo invocationModule = new PSModuleInfo(true);
invocationModule.SessionState.PSVariable.Set(nameof(lastHistory), (object)lastHistory);
invocationModule.SessionState.PSVariable.Set(nameof(lastError), lastError);
foreach (Hashtable suggestion in HostUtilities.suggestions)
{
int count = errorList.Count;
if (LanguagePrimitives.IsTrue(suggestion[(object)"Enabled"]))
{
SuggestionMatchType suggestionMatchType = (SuggestionMatchType)LanguagePrimitives.ConvertTo(suggestion[(object)"MatchType"], typeof(SuggestionMatchType), (IFormatProvider)CultureInfo.InvariantCulture);
if (suggestionMatchType == SuggestionMatchType.Dynamic)
{
if (!(suggestion[(object)"Rule"] is ScriptBlock sb))
{
suggestion[(object)"Enabled"] = (object)false;
throw new ArgumentException(ResourceManagerCache.GetResourceString("SuggestionStrings", "RuleMustBeScriptBlock"), "Rule");
}
object obj;
try
{
obj = invocationModule.Invoke(sb, (object[])null);
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
suggestion[(object)"Enabled"] = (object)false;
continue;
}
if (LanguagePrimitives.IsTrue(obj))
{
string suggestionText = HostUtilities.GetSuggestionText(suggestion[(object)"Suggestion"], invocationModule);
if (!string.IsNullOrEmpty(suggestionText))
{
string str = string.Format((IFormatProvider)Thread.CurrentThread.CurrentCulture, "Suggestion [{0},{1}]: {2}", (object)(int)suggestion[(object)"Id"], (object)(string)suggestion[(object)"Category"], (object)suggestionText);
arrayList.Add((object)str);
}
}
}
else
{
string input = string.Empty;
if (suggestionMatchType == SuggestionMatchType.Command)
{
input = lastHistory.CommandLine;
}
else if (suggestionMatchType == SuggestionMatchType.Error)
{
if (lastError != null)
{
input = !(lastError is Exception exception) ? lastError.ToString() : exception.Message;
}
}
else
{
suggestion[(object)"Enabled"] = (object)false;
throw new ArgumentException(ResourceManagerCache.GetResourceString("SuggestionStrings", "InvalidMatchType"), "MatchType");
}
if (Regex.IsMatch(input, (string)suggestion[(object)"Rule"], RegexOptions.IgnoreCase))
{
string suggestionText = HostUtilities.GetSuggestionText(suggestion[(object)"Suggestion"], invocationModule);
if (!string.IsNullOrEmpty(suggestionText))
{
string str = string.Format((IFormatProvider)Thread.CurrentThread.CurrentCulture, "Suggestion [{0},{1}]: {2}", (object)(int)suggestion[(object)"Id"], (object)(string)suggestion[(object)"Category"], (object)suggestionText);
arrayList.Add((object)str);
}
}
}
if (errorList.Count != count)
{
suggestion[(object)"Enabled"] = (object)false;
}
}
}
return(arrayList);
}
internal object Transform(EngineIntrinsics engineIntrinsics, object inputData, bool bindingParameters, bool bindingScriptCmdlet)
{
if (this._convertTypes == null)
{
return(inputData);
}
object obj2 = inputData;
try
{
for (int i = 0; i < this._convertTypes.Length; i++)
{
if (bindingParameters)
{
if (this._convertTypes[i].Equals(typeof(PSReference)))
{
object baseObject;
PSObject obj4 = obj2 as PSObject;
if (obj4 != null)
{
baseObject = obj4.BaseObject;
}
else
{
baseObject = obj2;
}
if (!(baseObject is PSReference))
{
throw new PSInvalidCastException("InvalidCastExceptionReferenceTypeExpected", null, ExtendedTypeSystem.ReferenceTypeExpected, new object[0]);
}
}
else
{
object obj5;
PSObject obj6 = obj2 as PSObject;
if (obj6 != null)
{
obj5 = obj6.BaseObject;
}
else
{
obj5 = obj2;
}
PSReference reference2 = obj5 as PSReference;
if (reference2 != null)
{
obj2 = reference2.Value;
}
if (bindingScriptCmdlet && (this._convertTypes[i] == typeof(string)))
{
obj5 = PSObject.Base(obj2);
if ((obj5 != null) && obj5.GetType().IsArray)
{
throw new PSInvalidCastException("InvalidCastFromAnyTypeToString", null, ExtendedTypeSystem.InvalidCastCannotRetrieveString, new object[0]);
}
}
}
}
if (LanguagePrimitives.IsBoolOrSwitchParameterType(this._convertTypes[i]))
{
CheckBoolValue(obj2, this._convertTypes[i]);
}
if (bindingScriptCmdlet)
{
ParameterCollectionTypeInformation information = new ParameterCollectionTypeInformation(this._convertTypes[i]);
if ((information.ParameterCollectionType != ParameterCollectionType.NotCollection) && LanguagePrimitives.IsBoolOrSwitchParameterType(information.ElementType))
{
IList iList = ParameterBinderBase.GetIList(obj2);
if (iList != null)
{
foreach (object obj7 in iList)
{
CheckBoolValue(obj7, information.ElementType);
}
}
else
{
CheckBoolValue(obj2, information.ElementType);
}
}
}
obj2 = LanguagePrimitives.ConvertTo(obj2, this._convertTypes[i], CultureInfo.InvariantCulture);
}
}
catch (PSInvalidCastException exception)
{
throw new ArgumentTransformationMetadataException(exception.Message, exception);
}
return(obj2);
}
internal static ArrayList GetSuggestion(HistoryInfo lastHistory, object lastError, ArrayList errorList)
{
ArrayList list = new ArrayList();
PSModuleInfo invocationModule = new PSModuleInfo(true);
invocationModule.SessionState.PSVariable.Set("lastHistory", lastHistory);
invocationModule.SessionState.PSVariable.Set("lastError", lastError);
int count = 0;
foreach (Hashtable hashtable in suggestions)
{
count = errorList.Count;
if (LanguagePrimitives.IsTrue(hashtable["Enabled"]))
{
SuggestionMatchType type = (SuggestionMatchType)LanguagePrimitives.ConvertTo(hashtable["MatchType"], typeof(SuggestionMatchType), CultureInfo.InvariantCulture);
if (type == SuggestionMatchType.Dynamic)
{
object obj2 = null;
ScriptBlock sb = hashtable["Rule"] as ScriptBlock;
if (sb == null)
{
hashtable["Enabled"] = false;
throw new ArgumentException(SuggestionStrings.RuleMustBeScriptBlock, "Rule");
}
try
{
obj2 = invocationModule.Invoke(sb, null);
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
hashtable["Enabled"] = false;
continue;
}
if (LanguagePrimitives.IsTrue(obj2))
{
string suggestionText = GetSuggestionText(hashtable["Suggestion"], invocationModule);
if (!string.IsNullOrEmpty(suggestionText))
{
string str2 = string.Format(Thread.CurrentThread.CurrentCulture, "Suggestion [{0},{1}]: {2}", new object[] { (int)hashtable["Id"], (string)hashtable["Category"], suggestionText });
list.Add(str2);
}
}
}
else
{
string input = string.Empty;
switch (type)
{
case SuggestionMatchType.Command:
input = lastHistory.CommandLine;
break;
case SuggestionMatchType.Error:
if (lastError != null)
{
Exception exception2 = lastError as Exception;
if (exception2 != null)
{
input = exception2.Message;
}
else
{
input = lastError.ToString();
}
}
break;
default:
hashtable["Enabled"] = false;
throw new ArgumentException(SuggestionStrings.InvalidMatchType, "MatchType");
}
if (Regex.IsMatch(input, (string)hashtable["Rule"], RegexOptions.IgnoreCase))
{
string str4 = GetSuggestionText(hashtable["Suggestion"], invocationModule);
if (!string.IsNullOrEmpty(str4))
{
string str5 = string.Format(Thread.CurrentThread.CurrentCulture, "Suggestion [{0},{1}]: {2}", new object[] { (int)hashtable["Id"], (string)hashtable["Category"], str4 });
list.Add(str5);
}
}
}
if (errorList.Count != count)
{
hashtable["Enabled"] = false;
}
}
}
return(list);
}
private void ReadXml()
{
try
{
Deserializer deserializer = new Deserializer(XmlReader.Create(this.streamReader, InternalDeserializer.XmlReaderSettingsForCliXml));
while (!deserializer.Done())
{
string str;
object obj2 = deserializer.Deserialize(out str);
MinishellStream unknown = MinishellStream.Unknown;
if (str != null)
{
unknown = StringToMinishellStreamConverter.ToMinishellStream(str);
}
if (unknown == MinishellStream.Unknown)
{
unknown = this.isOutput ? MinishellStream.Output : MinishellStream.Error;
}
if ((unknown == MinishellStream.Output) || (obj2 != null))
{
if (unknown == MinishellStream.Error)
{
if (obj2 is PSObject)
{
obj2 = ErrorRecord.FromPSObjectForRemoting(PSObject.AsPSObject(obj2));
}
else
{
string targetObject = null;
try
{
targetObject = (string)LanguagePrimitives.ConvertTo(obj2, typeof(string), CultureInfo.InvariantCulture);
}
catch (PSInvalidCastException)
{
continue;
}
obj2 = new ErrorRecord(new RemoteException(targetObject), "NativeCommandError", ErrorCategory.NotSpecified, targetObject);
}
}
else if (((unknown == MinishellStream.Debug) || (unknown == MinishellStream.Verbose)) || (unknown == MinishellStream.Warning))
{
try
{
obj2 = LanguagePrimitives.ConvertTo(obj2, typeof(string), CultureInfo.InvariantCulture);
}
catch (PSInvalidCastException)
{
continue;
}
}
this.AddObjectToWriter(obj2, unknown);
}
}
}
catch (XmlException exception)
{
string cliXmlError = NativeCP.CliXmlError;
XmlException exception2 = new XmlException(string.Format(null, cliXmlError, new object[] { this.isOutput ? MinishellStream.Output : MinishellStream.Error, this.processPath, exception.Message }), exception);
ErrorRecord data = new ErrorRecord(exception2, "ProcessStreamReader_CliXmlError", ErrorCategory.SyntaxError, this.processPath);
this.AddObjectToWriter(data, MinishellStream.Error);
}
}
internal object Transform(EngineIntrinsics engineIntrinsics, object inputData, bool bindingParameters, bool bindingScriptCmdlet)
{
if (_convertTypes == null)
{
return(inputData);
}
object result = inputData;
try
{
for (int i = 0; i < _convertTypes.Length; i++)
{
if (bindingParameters)
{
// We should not be doing a conversion here if [ref] is the last type.
// When [ref] appears in an argument list, it is used for checking only.
// No Conversion should be done.
if (_convertTypes[i].Equals(typeof(System.Management.Automation.PSReference)))
{
object temp;
PSObject mshObject = result as PSObject;
if (mshObject != null)
{
temp = mshObject.BaseObject;
}
else
{
temp = result;
}
PSReference reference = temp as PSReference;
if (reference == null)
{
throw new PSInvalidCastException("InvalidCastExceptionReferenceTypeExpected", null,
ExtendedTypeSystem.ReferenceTypeExpected);
}
}
else
{
object temp;
PSObject mshObject = result as PSObject;
if (mshObject != null)
{
temp = mshObject.BaseObject;
}
else
{
temp = result;
}
// If a non-ref type is expected but currently passed in is a ref, do an implicit dereference.
PSReference reference = temp as PSReference;
if (reference != null)
{
result = reference.Value;
}
if (bindingScriptCmdlet && _convertTypes[i] == typeof(string))
{
// Don't allow conversion from array to string in script w/ cmdlet binding. Allow
// the conversion for ordinary script parameter binding for V1 compatibility.
temp = PSObject.Base(result);
if (temp != null && temp.GetType().IsArray)
{
throw new PSInvalidCastException("InvalidCastFromAnyTypeToString", null,
ExtendedTypeSystem.InvalidCastCannotRetrieveString);
}
}
}
}
//BUGBUG
//NTRAID#Windows Out of Band Releases - 930116 - 03/14/06
//handling special case for boolean, switchparameter and Nullable<bool>
//These parameter types will not be converted if the incoming value types are not
//one of the accepted categories - $true/$false or numbers (0 or otherwise)
if (LanguagePrimitives.IsBoolOrSwitchParameterType(_convertTypes[i]))
{
CheckBoolValue(result, _convertTypes[i]);
}
if (bindingScriptCmdlet)
{
// Check for conversion to something like bool[] or ICollection<bool>, but only for cmdlet binding
// to stay compatible with V1.
ParameterCollectionTypeInformation collectionTypeInfo = new ParameterCollectionTypeInformation(_convertTypes[i]);
if (collectionTypeInfo.ParameterCollectionType != ParameterCollectionType.NotCollection &&
LanguagePrimitives.IsBoolOrSwitchParameterType(collectionTypeInfo.ElementType))
{
IList currentValueAsIList = ParameterBinderBase.GetIList(result);
if (currentValueAsIList != null)
{
foreach (object val in currentValueAsIList)
{
CheckBoolValue(val, collectionTypeInfo.ElementType);
}
}
else
{
CheckBoolValue(result, collectionTypeInfo.ElementType);
}
}
}
result = LanguagePrimitives.ConvertTo(result, _convertTypes[i], CultureInfo.InvariantCulture);
// Do validation of invalid direct variable assignments which are allowed to
// be used for parameters.
//
// Note - this is duplicated in ExecutionContext.cs as parameter binding for script cmdlets can avoid this code path.
if ((!bindingScriptCmdlet) && (!bindingParameters))
{
// ActionPreference of Suspend is not supported as a preference variable. We can only block "Suspend"
// during variable assignment (here) - "Ignore" is blocked during variable retrieval.
if (_convertTypes[i] == typeof(ActionPreference))
{
ActionPreference resultPreference = (ActionPreference)result;
if (resultPreference == ActionPreference.Suspend)
{
throw new PSInvalidCastException("InvalidActionPreference", null, ErrorPackage.UnsupportedPreferenceVariable, resultPreference);
}
}
}
}
}
catch (PSInvalidCastException e)
{
throw new ArgumentTransformationMetadataException(e.Message, e);
}
return(result);
}
internal bool ExistsInExpression(T flagName)
{
object enumVal = LanguagePrimitives.ConvertTo(flagName, this._underType, CultureInfo.InvariantCulture);
return(this._root.ExistEnum(enumVal));
}
public override string ToString()
{
return((string)LanguagePrimitives.ConvertTo(ImmediateBaseObject, typeof(string), Thread.CurrentThread.CurrentCulture));
}
private void HandleRunspaceCreated(object sender, RunspaceCreatedEventArgs args)
{
bool flag = false;
if (SystemPolicy.GetSystemLockdownPolicy() == SystemEnforcementMode.Enforce)
{
args.Runspace.ExecutionContext.LanguageMode = PSLanguageMode.ConstrainedLanguage;
flag = true;
}
try
{
string folderPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
args.Runspace.ExecutionContext.EngineSessionState.SetLocation(folderPath);
}
catch (ArgumentException)
{
}
catch (ProviderNotFoundException)
{
}
catch (DriveNotFoundException)
{
}
catch (ProviderInvocationException)
{
}
if (this.configHash != null)
{
if (this.configHash.ContainsKey(ConfigFileContants.EnvironmentVariables))
{
Hashtable hashtable = this.configHash[ConfigFileContants.EnvironmentVariables] as Hashtable;
if (hashtable != null)
{
foreach (DictionaryEntry entry in hashtable)
{
string introduced76 = entry.Key.ToString();
this.InvokeScript(new Command(StringUtil.Format("$env:{0} = \"{1}\"", introduced76, entry.Value.ToString()), true, false), args);
}
}
}
if (this.configHash.ContainsKey(ConfigFileContants.VariableDefinitions))
{
Hashtable[] hashtableArray = DISCPowerShellConfiguration.TryGetHashtableArray(this.configHash[ConfigFileContants.VariableDefinitions]);
if (hashtableArray != null)
{
foreach (Hashtable hashtable2 in hashtableArray)
{
if (hashtable2.ContainsKey(ConfigFileContants.VariableValueToken))
{
string str2 = DISCPowerShellConfiguration.TryGetValue(hashtable2, ConfigFileContants.VariableNameToken);
ScriptBlock block = hashtable2[ConfigFileContants.VariableValueToken] as ScriptBlock;
if (!string.IsNullOrEmpty(str2) && (block != null))
{
block.SessionStateInternal = args.Runspace.ExecutionContext.EngineSessionState;
PowerShell powershell = PowerShell.Create();
powershell.AddCommand(new Command("Invoke-Command")).AddParameter("ScriptBlock", block).AddParameter("NoNewScope");
powershell.AddCommand(new Command("Set-Variable")).AddParameter("Name", str2);
this.InvokePowerShell(powershell, args);
}
}
}
}
}
if (this.configHash.ContainsKey(ConfigFileContants.ScriptsToProcess))
{
string[] strArray = DISCPowerShellConfiguration.TryGetStringArray(this.configHash[ConfigFileContants.ScriptsToProcess]);
if (strArray != null)
{
foreach (string str3 in strArray)
{
if (!string.IsNullOrEmpty(str3))
{
this.InvokeScript(new Command(str3, true, false), args);
}
}
}
}
bool flag2 = false;
if (this.configHash.ContainsKey(ConfigFileContants.VisibleAliases))
{
string[] strArray2 = DISCPowerShellConfiguration.TryGetStringArray(this.configHash[ConfigFileContants.VisibleAliases]);
if (strArray2 != null)
{
flag2 = true;
foreach (KeyValuePair <string, AliasInfo> pair in args.Runspace.ExecutionContext.EngineSessionState.GetAliasTable())
{
bool flag3 = false;
foreach (string str4 in strArray2)
{
if (!string.IsNullOrEmpty(str4))
{
IEnumerable <WildcardPattern> patternList = this.CreateKeyPatternList(str4);
if (this.MatchKeyPattern(patternList, pair.Key))
{
pair.Value.Visibility = SessionStateEntryVisibility.Public;
flag3 = true;
}
}
}
if (!flag3)
{
pair.Value.Visibility = SessionStateEntryVisibility.Private;
}
}
}
}
if (this.configHash.ContainsKey(ConfigFileContants.VisibleCmdlets))
{
string[] strArray3 = DISCPowerShellConfiguration.TryGetStringArray(this.configHash[ConfigFileContants.VisibleCmdlets]);
if (strArray3 != null)
{
flag2 = true;
foreach (KeyValuePair <string, List <CmdletInfo> > pair2 in args.Runspace.ExecutionContext.EngineSessionState.GetCmdletTable())
{
bool flag4 = false;
foreach (string str5 in strArray3)
{
if (!string.IsNullOrEmpty(str5))
{
IEnumerable <WildcardPattern> enumerable2 = this.CreateKeyPatternList(str5);
if (this.MatchKeyPattern(enumerable2, pair2.Key))
{
foreach (CmdletInfo info in pair2.Value)
{
info.Visibility = SessionStateEntryVisibility.Public;
flag4 = true;
}
}
}
}
if (!flag4)
{
foreach (CmdletInfo info2 in pair2.Value)
{
info2.Visibility = SessionStateEntryVisibility.Private;
}
}
}
}
}
List <string> list = new List <string>();
bool flag5 = false;
if (this.configHash.ContainsKey(ConfigFileContants.VisibleFunctions))
{
string[] strArray4 = DISCPowerShellConfiguration.TryGetStringArray(this.configHash[ConfigFileContants.VisibleFunctions]);
if (strArray4 != null)
{
flag2 = true;
flag5 = true;
list.AddRange(strArray4);
}
}
if (!flag5 && this.configHash.ContainsKey(ConfigFileContants.FunctionDefinitions))
{
Hashtable[] hashtableArray2 = DISCPowerShellConfiguration.TryGetHashtableArray(this.configHash[ConfigFileContants.FunctionDefinitions]);
if (hashtableArray2 != null)
{
foreach (Hashtable hashtable3 in hashtableArray2)
{
string str6 = DISCPowerShellConfiguration.TryGetValue(hashtable3, ConfigFileContants.FunctionNameToken);
if (!string.IsNullOrEmpty(str6))
{
list.Add(str6);
}
}
}
}
string str7 = DISCPowerShellConfiguration.TryGetValue(this.configHash, ConfigFileContants.SessionType);
if (!string.IsNullOrEmpty(str7))
{
SessionType type = (SessionType)Enum.Parse(typeof(SessionType), str7, true);
if (type == SessionType.RestrictedRemoteServer)
{
list.Add("Get-Command");
list.Add("Get-FormatData");
list.Add("Select-Object");
list.Add("Get-Help");
list.Add("Measure-Object");
list.Add("Out-Default");
list.Add("Exit-PSSession");
}
}
if (list.Count > 0)
{
foreach (DictionaryEntry entry2 in args.Runspace.ExecutionContext.EngineSessionState.GetFunctionTable())
{
bool flag6 = false;
string key = entry2.Key.ToString();
FunctionInfo info3 = entry2.Value as FunctionInfo;
if (info3 != null)
{
foreach (string str9 in list)
{
if (!string.IsNullOrEmpty(str9))
{
IEnumerable <WildcardPattern> enumerable3 = this.CreateKeyPatternList(str9);
if (this.MatchKeyPattern(enumerable3, key))
{
info3.Visibility = SessionStateEntryVisibility.Public;
flag6 = true;
}
}
}
if (!flag6 && flag5)
{
info3.Visibility = SessionStateEntryVisibility.Private;
}
}
}
}
if (this.configHash.ContainsKey(ConfigFileContants.VisibleProviders))
{
string[] strArray5 = DISCPowerShellConfiguration.TryGetStringArray(this.configHash[ConfigFileContants.VisibleProviders]);
if (strArray5 != null)
{
flag2 = true;
IDictionary <string, List <ProviderInfo> > providers = args.Runspace.ExecutionContext.EngineSessionState.Providers;
Collection <string> collection = new Collection <string>();
foreach (KeyValuePair <string, List <ProviderInfo> > pair3 in providers)
{
bool flag7 = false;
foreach (string str10 in strArray5)
{
if (!string.IsNullOrEmpty(str10))
{
IEnumerable <WildcardPattern> enumerable4 = this.CreateKeyPatternList(str10);
if (this.MatchKeyPattern(enumerable4, pair3.Key))
{
flag7 = true;
}
}
}
if (!flag7)
{
collection.Add(pair3.Key);
}
}
foreach (string str11 in collection)
{
args.Runspace.ExecutionContext.EngineSessionState.Providers.Remove(str11);
}
}
}
if (flag2)
{
CmdletInfo cmdlet = args.Runspace.ExecutionContext.SessionState.InvokeCommand.GetCmdlet(@"Microsoft.PowerShell.Core\Import-Module");
IDictionary <string, AliasInfo> aliasTable = args.Runspace.ExecutionContext.EngineSessionState.GetAliasTable();
PSModuleAutoLoadingPreference preference = CommandDiscovery.GetCommandDiscoveryPreference(args.Runspace.ExecutionContext, SpecialVariables.PSModuleAutoLoadingPreferenceVarPath, "PSModuleAutoLoadingPreference");
bool flag8 = (cmdlet != null) && (cmdlet.Visibility != SessionStateEntryVisibility.Private);
bool flag9 = ((aliasTable != null) && aliasTable.ContainsKey("ipmo")) && (aliasTable["ipmo"].Visibility != SessionStateEntryVisibility.Private);
if ((flag8 || flag9) && (preference == PSModuleAutoLoadingPreference.None))
{
throw new PSInvalidOperationException(StringUtil.Format(RemotingErrorIdStrings.DISCVisibilityAndAutoLoadingCannotBeBothSpecified, new object[] { "Import-Module", "ipmo", ConfigFileContants.VisibleCmdlets, ConfigFileContants.VisibleAliases, ConfigFileContants.VisibleFunctions, ConfigFileContants.VisibleProviders }));
}
}
if (this.configHash.ContainsKey(ConfigFileContants.LanguageMode))
{
PSLanguageMode mode = (PSLanguageMode)Enum.Parse(typeof(PSLanguageMode), this.configHash[ConfigFileContants.LanguageMode].ToString(), true);
if (flag && (mode != PSLanguageMode.ConstrainedLanguage))
{
throw new PSInvalidOperationException(RemotingErrorIdStrings.CannotCreateRunspaceInconsistentState);
}
args.Runspace.ExecutionContext.LanguageMode = mode;
}
if (this.configHash.ContainsKey(ConfigFileContants.ExecutionPolicy))
{
ExecutionPolicy policy = (ExecutionPolicy)Enum.Parse(typeof(ExecutionPolicy), this.configHash[ConfigFileContants.ExecutionPolicy].ToString(), true);
string shellID = args.Runspace.ExecutionContext.ShellID;
SecuritySupport.SetExecutionPolicy(ExecutionPolicyScope.Process, policy, shellID);
}
}
Command cmdToRun = null;
if (!string.IsNullOrEmpty(this.configData.StartupScript))
{
cmdToRun = new Command(this.configData.StartupScript, false, false);
}
else if (!string.IsNullOrEmpty(this.configData.InitializationScriptForOutOfProcessRunspace))
{
cmdToRun = new Command(this.configData.InitializationScriptForOutOfProcessRunspace, true, false);
}
if (cmdToRun != null)
{
this.InvokeScript(cmdToRun, args);
if (this.localRunspacePool.RunspacePoolStateInfo.State == RunspacePoolState.Opening)
{
object valueToConvert = args.Runspace.SessionStateProxy.PSVariable.GetValue("global:PSApplicationPrivateData");
if (valueToConvert != null)
{
this.applicationPrivateData = (PSPrimitiveDictionary)LanguagePrimitives.ConvertTo(valueToConvert, typeof(PSPrimitiveDictionary), true, CultureInfo.InvariantCulture, null);
}
}
}
}
internal static object GetMDArrayValueOrSlice(Array array, object indexes)
{
Exception whyFailed = null;
int[] indexArray = null;
try
{
indexArray = (int[])LanguagePrimitives.ConvertTo(indexes, typeof(int[]), NumberFormatInfo.InvariantInfo);
}
catch (InvalidCastException ice)
{
// Ignore an exception here as we may actually be looking at an array of arrays
// which could still be ok. Save the exception as we may use it later...
whyFailed = ice;
}
if (indexArray != null)
{
if (indexArray.Length != array.Rank)
{
// rank failed to match so error...
ReportIndexingError(array, indexes, null);
}
return(GetMDArrayValue(array, indexArray, false));
}
var indexList = new List <int[]>();
var ie = LanguagePrimitives.GetEnumerator(indexes);
while (EnumerableOps.MoveNext(null, ie))
{
var currentIndex = EnumerableOps.Current(ie);
try
{
indexArray = LanguagePrimitives.ConvertTo <int[]>(currentIndex);
}
catch (InvalidCastException)
{
indexArray = null;
}
if (indexArray == null || indexArray.Length != array.Rank)
{
if (whyFailed != null)
{
// If the first fails, report the original exception and all indices
ReportIndexingError(array, indexes, whyFailed);
Diagnostics.Assert(false, "ReportIndexingError must throw");
}
// If the second or subsequent index fails, report the failure for just that index
ReportIndexingError(array, currentIndex, null);
Diagnostics.Assert(false, "ReportIndexingError must throw");
}
// Only use whyFailed the first time through, otherwise
whyFailed = null;
indexList.Add(indexArray);
}
// Optimistically assume all indices are valid so the result array is the same size.
// If that turns out to be wrong, we'll just copy the elements produced.
var result = new object[indexList.Count];
int j = 0;
foreach (var i in indexList)
{
var value = GetMDArrayValue(array, i, true);
if (value != AutomationNull.Value)
{
result[j++] = value;
}
}
if (j != indexList.Count)
{
var shortResult = new object[j];
Array.Copy(result, shortResult, j);
return(shortResult);
}
return(result);
}
//todo: do something with ignoreCase
public override object ConvertFrom(object sourceValue, Type destinationType, IFormatProvider formatProvider, bool ignoreCase)
{
return(LanguagePrimitives.ConvertTo(
(LanguagePrimitives.ConvertTo(sourceValue, typeof(string), formatProvider) as String),
destinationType, formatProvider));
}
/// <summary>
/// Evaluate a given flag enum value against the expression.
/// </summary>
/// <param name="value">
/// The flag enum value to be evaluated.
/// </param>
/// <returns>
/// Whether the enum value satisfy the expression.
/// </returns>
public bool Evaluate(T value)
{
object val = LanguagePrimitives.ConvertTo(value, _underType, CultureInfo.InvariantCulture);
return(Root.Eval(val));
}
internal static object GetMDArrayValueOrSlice(Array array, object indexes)
{
Exception reason = null;
int[] numArray = null;
try
{
numArray = (int[])LanguagePrimitives.ConvertTo(indexes, typeof(int[]), NumberFormatInfo.InvariantInfo);
}
catch (InvalidCastException exception2)
{
reason = exception2;
}
if (numArray != null)
{
if (numArray.Length != array.Rank)
{
ReportIndexingError(array, indexes, null);
}
return(GetMDArrayValue(array, numArray, false));
}
List <int[]> list = new List <int[]>();
IEnumerator enumerator = LanguagePrimitives.GetEnumerator(indexes);
while (EnumerableOps.MoveNext(null, enumerator))
{
object valueToConvert = EnumerableOps.Current(enumerator);
try
{
numArray = LanguagePrimitives.ConvertTo <int[]>(valueToConvert);
}
catch (InvalidCastException)
{
numArray = null;
}
if ((numArray == null) || (numArray.Length != array.Rank))
{
if (reason != null)
{
ReportIndexingError(array, indexes, reason);
}
ReportIndexingError(array, valueToConvert, null);
}
reason = null;
list.Add(numArray);
}
object[] sourceArray = new object[list.Count];
int length = 0;
foreach (int[] numArray2 in list)
{
object obj3 = GetMDArrayValue(array, numArray2, true);
if (obj3 != AutomationNull.Value)
{
sourceArray[length++] = obj3;
}
}
if (length != list.Count)
{
object[] destinationArray = new object[length];
Array.Copy(sourceArray, destinationArray, length);
return(destinationArray);
}
return(sourceArray);
}
