private static string GetObjectName(object x, MshExpressionFactory expressionFactory)
{
if ((x is PSObject) && ((LanguagePrimitives.IsBoolOrSwitchParameterType(((PSObject)x).BaseObject.GetType()) || LanguagePrimitives.IsNumeric(Type.GetTypeCode(((PSObject)x).BaseObject.GetType()))) || LanguagePrimitives.IsNull(x)))
{
return(x.ToString());
}
if (x == null)
{
return("$null");
}
MethodInfo info = x.GetType().GetMethod("ToString", Type.EmptyTypes, null);
if (info.DeclaringType.Equals(info.ReflectedType))
{
return(AsPSObject(x).ToString());
}
MshExpressionResult displayName = GetDisplayName(AsPSObject(x), expressionFactory);
if ((displayName != null) && (displayName.Exception == null))
{
return(AsPSObject(displayName.Result).ToString());
}
string str = AsPSObject(x).ToString();
if (str == string.Empty)
{
object obj2 = PSObject.Base(x);
if (obj2 != null)
{
str = obj2.ToString();
}
}
return(str);
}
private static string GetSmartToStringDisplayName(
object x,
MshExpressionFactory expressionFactory)
{
MshExpressionResult displayName = PSObjectHelper.GetDisplayName(PSObjectHelper.AsPSObject(x), expressionFactory);
return(displayName != null && displayName.Exception == null?PSObjectHelper.AsPSObject(displayName.Result).ToString() : PSObjectHelper.AsPSObject(x).ToString());
}
private static string GetSmartToStringDisplayName(object x, MshExpressionFactory expressionFactory)
{
MshExpressionResult displayName = GetDisplayName(AsPSObject(x), expressionFactory);
if ((displayName != null) && (displayName.Exception == null))
{
return(AsPSObject(displayName.Result).ToString());
}
return(AsPSObject(x).ToString());
}
internal void LogMshExpressionFailedResult(MshExpressionResult result, object sourceObject)
{
if (this.formatErrorPolicy.ShowErrorsAsMessages)
{
MshExpressionError item = new MshExpressionError {
result = result,
sourceObject = sourceObject
};
this.formattingErrorList.Add(item);
}
}
internal void LogMshExpressionFailedResult(MshExpressionResult result, object sourceObject)
{
if (this.formatErrorPolicy.ShowErrorsAsMessages)
{
MshExpressionError item = new MshExpressionError {
result = result,
sourceObject = sourceObject
};
this.formattingErrorList.Add(item);
}
}
/// <summary>
/// log a failed evaluation of an MshExpression
/// </summary>
/// <param name="result">MshExpressionResult containing the failed evaluation data</param>
/// <param name="sourceObject">object used to evaluate the MshExpression</param>
internal void LogMshExpressionFailedResult(MshExpressionResult result, object sourceObject)
{
if (!_formatErrorPolicy.ShowErrorsAsMessages)
{
return;
}
MshExpressionError error = new MshExpressionError();
error.result = result;
error.sourceObject = sourceObject;
_formattingErrorList.Add(error);
}
private static string GetSmartToStringDisplayName(object x, MshExpressionFactory expressionFactory)
{
MshExpressionResult r = PSObjectHelper.GetDisplayName(PSObjectHelper.AsPSObject(x), expressionFactory);
if ((r != null) && (r.Exception == null))
{
return(PSObjectHelper.AsPSObject(r.Result).ToString());
}
else
{
return(PSObjectHelper.AsPSObject(x).ToString());
}
}
internal static bool Evaluate(PSObject obj, MshExpression ex, out MshExpressionResult expressionResult)
{
expressionResult = null;
List<MshExpressionResult> res = ex.GetValues(obj);
if (res.Count == 0)
return false;
if (res[0].Exception != null)
{
expressionResult = res[0];
return false;
}
return LanguagePrimitives.IsTrue(res[0].Result);
}
private static string GetObjectName(object x, MshExpressionFactory expressionFactory)
{
string objName;
// check if the underlying object is of primitive type
// if so just return its value
if (x is PSObject &&
(LanguagePrimitives.IsBoolOrSwitchParameterType((((PSObject)x).BaseObject).GetType()) ||
LanguagePrimitives.IsNumeric(((((PSObject)x).BaseObject).GetType()).GetTypeCode()) ||
LanguagePrimitives.IsNull(x)))
{
objName = x.ToString();
}
else if (x == null)
{
// use PowerShell's $null variable to indicate that the value is null...
objName = "$null";
}
else
{
MethodInfo toStringMethod = x.GetType().GetMethod("ToString", PSTypeExtensions.EmptyTypes);
// TODO:CORECLR double check with CORE CLR that x.GetType() == toStringMethod.ReflectedType
// Check if the given object "x" implements "toString" method. Do that by comparing "DeclaringType" which 'Gets the class that declares this member' and the object type
if (toStringMethod.DeclaringType == x.GetType())
{
objName = PSObjectHelper.AsPSObject(x).ToString();
}
else
{
MshExpressionResult r = PSObjectHelper.GetDisplayName(PSObjectHelper.AsPSObject(x), expressionFactory);
if ((r != null) && (r.Exception == null))
{
objName = PSObjectHelper.AsPSObject(r.Result).ToString();;
}
else
{
objName = PSObjectHelper.AsPSObject(x).ToString();
if (objName == string.Empty)
{
var baseObj = PSObject.Base(x);
if (baseObj != null)
{
objName = baseObj.ToString();
}
}
}
}
}
return(objName);
}
internal static bool Evaluate(PSObject obj, MshExpression ex, out MshExpressionResult expressionResult)
{
expressionResult = null;
List <MshExpressionResult> res = ex.GetValues(obj);
if (res.Count == 0)
{
return(false);
}
if (res[0].Exception != null)
{
expressionResult = res[0];
return(false);
}
return(LanguagePrimitives.IsTrue(res[0].Result));
}
internal List <MshExpressionResult> GetValues(PSObject target, bool expand, bool eatExceptions)
{
List <MshExpressionResult> list = new List <MshExpressionResult>();
if (this._script != null)
{
MshExpressionResult item = new MshExpression(this._script).GetValue(target, eatExceptions);
list.Add(item);
return(list);
}
foreach (MshExpression expression2 in this.ResolveNames(target, expand))
{
MshExpressionResult result2 = expression2.GetValue(target, eatExceptions);
list.Add(result2);
}
return(list);
}
internal static string GetExpressionDisplayValue(
PSObject so,
int enumerationLimit,
MshExpression ex,
FieldFormattingDirective directive,
StringFormatError formatErrorObject,
MshExpressionFactory expressionFactory,
out MshExpressionResult result)
{
result = (MshExpressionResult)null;
List <MshExpressionResult> values = ex.GetValues(so);
if (values.Count == 0)
{
return("");
}
result = values[0];
return(result.Exception != null ? "" : PSObjectHelper.FormatField(directive, result.Result, enumerationLimit, formatErrorObject, expressionFactory));
}
internal List <MshExpressionResult> GetValues(PSObject target, bool expand, bool eatExceptions)
{
List <MshExpressionResult> retVal = new List <MshExpressionResult>();
// process the script case
if (Script != null)
{
MshExpression scriptExpression = new MshExpression(Script);
MshExpressionResult r = scriptExpression.GetValue(target, eatExceptions);
retVal.Add(r);
return(retVal);
}
// process the expression
List <MshExpression> resolvedExpressionList = this.ResolveNames(target, expand);
foreach (MshExpression re in resolvedExpressionList)
{
MshExpressionResult r = re.GetValue(target, eatExceptions);
retVal.Add(r);
}
return(retVal);
}
protected FormatPropertyField GenerateFormatPropertyField(List<FormatToken> formatTokenList, PSObject so, int enumerationLimit, out MshExpressionResult result)
{
result = null;
FormatPropertyField field = new FormatPropertyField();
if (formatTokenList.Count != 0)
{
FormatToken token = formatTokenList[0];
FieldPropertyToken token2 = token as FieldPropertyToken;
if (token2 != null)
{
MshExpression ex = this.expressionFactory.CreateFromExpressionToken(token2.expression, this.dataBaseInfo.view.loadingInfo);
field.propertyValue = this.GetExpressionDisplayValue(so, enumerationLimit, ex, token2.fieldFormattingDirective, out result);
return field;
}
TextToken tt = token as TextToken;
if (tt != null)
{
field.propertyValue = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(tt);
}
return field;
}
field.propertyValue = "";
return field;
}
/// <summary>
/// helper to retrieve the value of an MshExpression and to format it
/// </summary>
/// <param name="so">shell object to process</param>
/// <param name="enumerationLimit">limit on IEnumerable enumeration</param>
/// <param name="ex">expression to use for retrieval</param>
/// <param name="directive">format directive to use for formatting</param>
/// <param name="formatErrorObject"></param>
/// <param name="expressionFactory">expression factory to create MshExpression</param>
/// <param name="result"> not null if an error condition arose</param>
/// <returns>formatted string</returns>
internal static string GetExpressionDisplayValue(
PSObject so,
int enumerationLimit,
MshExpression ex,
FieldFormattingDirective directive,
StringFormatError formatErrorObject,
MshExpressionFactory expressionFactory,
out MshExpressionResult result)
{
result = null;
List <MshExpressionResult> resList = ex.GetValues(so);
if (resList.Count == 0)
{
return(string.Empty);
}
result = resList[0];
if (result.Exception != null)
{
return(string.Empty);
}
return(PSObjectHelper.FormatField(directive, result.Result, enumerationLimit, formatErrorObject, expressionFactory));
}
protected string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex, FieldFormattingDirective directive, out MshExpressionResult expressionResult)
{
StringFormatError formatErrorObject = null;
if (this.errorManager.DisplayFormatErrorString)
{
formatErrorObject = new StringFormatError();
}
string errorString = PSObjectHelper.GetExpressionDisplayValue(so, enumerationLimit, ex, directive, formatErrorObject, this.expressionFactory, out expressionResult);
if (expressionResult != null)
{
if (expressionResult.Exception != null)
{
this.errorManager.LogMshExpressionFailedResult(expressionResult, so);
if (this.errorManager.DisplayErrorStrings)
{
errorString = this.errorManager.ErrorString;
}
return errorString;
}
if ((formatErrorObject != null) && (formatErrorObject.exception != null))
{
this.errorManager.LogStringFormatError(formatErrorObject);
if (this.errorManager.DisplayErrorStrings)
{
errorString = this.errorManager.FormatErrorString;
}
}
}
return errorString;
}
/// <summary>
/// log a failed evaluation of an MshExpression
/// </summary>
/// <param name="result">MshExpressionResult containing the failed evaluation data</param>
/// <param name="sourceObject">object used to evaluate the MshExpression</param>
internal void LogMshExpressionFailedResult(MshExpressionResult result, object sourceObject)
{
if (!_formatErrorPolicy.ShowErrorsAsMessages)
return;
MshExpressionError error = new MshExpressionError();
error.result = result;
error.sourceObject = sourceObject;
_formattingErrorList.Add(error);
}
private void ProcessActiveAssociationList(PSObject so, TraversalInfo currentLevel, List <MshResolvedExpressionParameterAssociation> activeAssociationList, List <FormatValue> formatValueList)
{
foreach (MshResolvedExpressionParameterAssociation association in activeAssociationList)
{
FormatTextField item = new FormatTextField {
text = association.ResolvedExpression.ToString() + " = "
};
formatValueList.Add(item);
List <MshExpressionResult> values = association.ResolvedExpression.GetValues(so);
object errorString = null;
if (values.Count >= 1)
{
MshExpressionResult result = values[0];
if (result.Exception != null)
{
this.errorManager.LogMshExpressionFailedResult(result, so);
if (this.errorManager.DisplayErrorStrings)
{
errorString = this.errorManager.ErrorString;
}
else
{
errorString = "";
}
}
else
{
errorString = result.Result;
}
}
TraversalInfo level = currentLevel;
if (association.OriginatingParameter != null)
{
object entry = association.OriginatingParameter.GetEntry("depth");
if (entry != AutomationNull.Value)
{
int maxDepth = (int)entry;
level = new TraversalInfo(currentLevel.Level, maxDepth);
}
}
IEnumerable e = null;
if ((errorString != null) || (level.Level >= level.MaxDepth))
{
e = PSObjectHelper.GetEnumerable(errorString);
}
if (e != null)
{
formatValueList.Add(new FormatNewLine());
this.DisplayEnumeration(e, level.NextLevel, this.AddIndentationLevel(formatValueList));
}
else if ((errorString == null) || TreatAsLeafNode(errorString, level))
{
this.DisplayLeaf(errorString, formatValueList);
}
else
{
formatValueList.Add(new FormatNewLine());
this.DisplayObject(PSObject.AsPSObject(errorString), level.NextLevel, null, this.AddIndentationLevel(formatValueList));
}
}
}
protected string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex, FieldFormattingDirective directive, out MshExpressionResult expressionResult)
{
StringFormatError formatErrorObject = null;
if (this.errorManager.DisplayFormatErrorString)
{
formatErrorObject = new StringFormatError();
}
string errorString = PSObjectHelper.GetExpressionDisplayValue(so, enumerationLimit, ex, directive, formatErrorObject, this.expressionFactory, out expressionResult);
if (expressionResult != null)
{
if (expressionResult.Exception != null)
{
this.errorManager.LogMshExpressionFailedResult(expressionResult, so);
if (this.errorManager.DisplayErrorStrings)
{
errorString = this.errorManager.ErrorString;
}
return(errorString);
}
if ((formatErrorObject != null) && (formatErrorObject.exception != null))
{
this.errorManager.LogStringFormatError(formatErrorObject);
if (this.errorManager.DisplayErrorStrings)
{
errorString = this.errorManager.FormatErrorString;
}
}
}
return(errorString);
}
protected string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex,
FieldFormattingDirective directive, out MshExpressionResult expressionResult)
{
StringFormatError formatErrorObject = null;
if (_errorManager.DisplayFormatErrorString)
{
// we send a format error object down to the formatting calls
// only if we want to show the formatting error strings
formatErrorObject = new StringFormatError();
}
string retVal = PSObjectHelper.GetExpressionDisplayValue(so, enumerationLimit, ex,
directive, formatErrorObject, expressionFactory, out expressionResult);
if (expressionResult != null)
{
// we obtained a result, check if there is an error
if (expressionResult.Exception != null)
{
_errorManager.LogMshExpressionFailedResult(expressionResult, so);
if (_errorManager.DisplayErrorStrings)
{
retVal = _errorManager.ErrorString;
}
}
else if (formatErrorObject != null && formatErrorObject.exception != null)
{
// if we did no thave any errors in the expression evaluation
// we might have errors in the formatting, if present
_errorManager.LogStringFormatError(formatErrorObject);
if (_errorManager.DisplayErrorStrings)
{
retVal = _errorManager.FormatErrorString;
}
}
}
return retVal;
}
private void ProcessActiveAssociationList(PSObject so,
TraversalInfo currentLevel,
List <MshResolvedExpressionParameterAssociation> activeAssociationList,
List <FormatValue> formatValueList)
{
foreach (MshResolvedExpressionParameterAssociation a in activeAssociationList)
{
FormatTextField ftf = new FormatTextField();
ftf.text = a.ResolvedExpression.ToString() + " = ";
formatValueList.Add(ftf);
// compute the value of the entry
List <MshExpressionResult> resList = a.ResolvedExpression.GetValues(so);
object val = null;
if (resList.Count >= 1)
{
MshExpressionResult result = resList[0];
if (result.Exception != null)
{
_errorManager.LogMshExpressionFailedResult(result, so);
if (_errorManager.DisplayErrorStrings)
{
val = _errorManager.ErrorString;
}
else
{
val = string.Empty;
}
}
else
{
val = result.Result;
}
}
// extract the optional max depth
TraversalInfo level = currentLevel;
if (a.OriginatingParameter != null)
{
object maxDepthKey = a.OriginatingParameter.GetEntry(FormatParameterDefinitionKeys.DepthEntryKey);
if (maxDepthKey != AutomationNull.Value)
{
int parameterMaxDept = (int)maxDepthKey;
level = new TraversalInfo(currentLevel.Level, parameterMaxDept);
}
}
IEnumerable e = null;
if (val != null || (level.Level >= level.MaxDepth))
{
e = PSObjectHelper.GetEnumerable(val);
}
if (e != null)
{
formatValueList.Add(new FormatNewLine());
DisplayEnumeration(e, level.NextLevel, AddIndentationLevel(formatValueList));
}
else if (val == null || TreatAsLeafNode(val, level))
{
DisplayLeaf(val, formatValueList);
}
else
{
formatValueList.Add(new FormatNewLine());
// we need to go one more level down
DisplayObject(PSObject.AsPSObject(val), level.NextLevel, null,
AddIndentationLevel(formatValueList));
}
} // for each
}
protected string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex,
FieldFormattingDirective directive, out MshExpressionResult expressionResult)
{
StringFormatError formatErrorObject = null;
if (_errorManager.DisplayFormatErrorString)
{
// we send a format error object down to the formatting calls
// only if we want to show the formatting error strings
formatErrorObject = new StringFormatError();
}
string retVal = PSObjectHelper.GetExpressionDisplayValue(so, enumerationLimit, ex,
directive, formatErrorObject, expressionFactory, out expressionResult);
if (expressionResult != null)
{
// we obtained a result, check if there is an error
if (expressionResult.Exception != null)
{
_errorManager.LogMshExpressionFailedResult(expressionResult, so);
if (_errorManager.DisplayErrorStrings)
{
retVal = _errorManager.ErrorString;
}
}
else if (formatErrorObject != null && formatErrorObject.exception != null)
{
// if we did no thave any errors in the expression evaluation
// we might have errors in the formatting, if present
_errorManager.LogStringFormatError(formatErrorObject);
if (_errorManager.DisplayErrorStrings)
{
retVal = _errorManager.FormatErrorString;
}
}
}
return(retVal);
}
protected FormatPropertyField GenerateFormatPropertyField(List <FormatToken> formatTokenList, PSObject so, int enumerationLimit, out MshExpressionResult result)
{
result = null;
FormatPropertyField fpf = new FormatPropertyField();
if (formatTokenList.Count != 0)
{
FormatToken token = formatTokenList[0];
FieldPropertyToken fpt = token as FieldPropertyToken;
if (fpt != null)
{
MshExpression ex = this.expressionFactory.CreateFromExpressionToken(fpt.expression, this.dataBaseInfo.view.loadingInfo);
fpf.propertyValue = this.GetExpressionDisplayValue(so, enumerationLimit, ex, fpt.fieldFormattingDirective, out result);
}
else
{
TextToken tt = token as TextToken;
if (tt != null)
{
fpf.propertyValue = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(tt);
}
}
}
else
{
fpf.propertyValue = "";
}
return(fpf);
}
/// <summary>
/// helper to retrieve the value of an MshExpression and to format it
/// </summary>
/// <param name="so">shell object to process</param>
/// <param name="enumerationLimit">limit on IEnumerable enumeration</param>
/// <param name="ex">expression to use for retrieval</param>
/// <param name="directive">format directive to use for formatting</param>
/// <param name="formatErrorObject"></param>
/// <param name="expressionFactory">expression factory to create MshExpression</param>
/// <param name="result"> not null if an error condition arose</param>
/// <returns>formatted string</returns>
internal static string GetExpressionDisplayValue(
PSObject so,
int enumerationLimit,
MshExpression ex,
FieldFormattingDirective directive,
StringFormatError formatErrorObject,
MshExpressionFactory expressionFactory,
out MshExpressionResult result)
{
result = null;
List<MshExpressionResult> resList = ex.GetValues(so);
if (resList.Count == 0)
{
return "";
}
result = resList[0];
if (result.Exception != null)
{
return "";
}
return PSObjectHelper.FormatField(directive, result.Result, enumerationLimit, formatErrorObject, expressionFactory);
}
internal static string SmartToString(
PSObject so,
MshExpressionFactory expressionFactory,
int enumerationLimit,
StringFormatError formatErrorObject)
{
if (so == null)
{
return("");
}
try
{
IEnumerable enumerable = PSObjectHelper.GetEnumerable((object)so);
if (enumerable == null)
{
return(so.ToString());
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("{");
bool flag = true;
int num = 0;
if (enumerable.GetEnumerator() != null)
{
foreach (object obj in enumerable)
{
if (LocalPipeline.GetExecutionContextFromTLS().CurrentPipelineStopping)
{
throw new PipelineStoppedException();
}
if (enumerationLimit >= 0)
{
if (num == enumerationLimit)
{
stringBuilder.Append("...");
break;
}
++num;
}
string str;
if (obj is PSObject && (LanguagePrimitives.IsBoolOrSwitchParameterType(((PSObject)obj).BaseObject.GetType()) || LanguagePrimitives.IsNumeric(Type.GetTypeCode(((PSObject)obj).BaseObject.GetType())) || LanguagePrimitives.IsNull(obj)))
{
str = obj.ToString();
}
else if (obj == null)
{
str = "$null";
}
else
{
MethodInfo method = obj.GetType().GetMethod("ToString", Type.EmptyTypes, (ParameterModifier[])null);
if (method.DeclaringType.Equals(method.ReflectedType))
{
str = PSObjectHelper.AsPSObject(obj).ToString();
}
else
{
MshExpressionResult displayName = PSObjectHelper.GetDisplayName(PSObjectHelper.AsPSObject(obj), expressionFactory);
str = displayName == null || displayName.Exception != null?PSObjectHelper.AsPSObject(obj).ToString() : PSObjectHelper.AsPSObject(displayName.Result).ToString();
}
}
if (!flag)
{
stringBuilder.Append(", ");
}
stringBuilder.Append(str);
if (flag)
{
flag = false;
}
}
}
stringBuilder.Append("}");
return(stringBuilder.ToString());
}
catch (ExtendedTypeSystemException ex)
{
if (formatErrorObject != null)
{
formatErrorObject.sourceObject = (object)so;
formatErrorObject.exception = (Exception)ex;
}
return("");
}
}