private static MshExpression GetDefaultNameExpression(PSObject so) { MshExpression retVal = GetDefaultNameExpression(so.PSStandardMembers) ?? GetDefaultNameExpression(MaskDeserializedAndGetStandardMembers(so)); return(retVal); }
internal MshExpression CreateFromExpressionToken(ExpressionToken et, DatabaseLoadingInfo loadingInfo) { if (!et.isScriptBlock) { return(new MshExpression(et.expressionValue)); } if (this._expressionCache != null) { MshExpression expression; if (this._expressionCache.TryGetValue(et, out expression)) { return(expression); } } else { this._expressionCache = new Dictionary <ExpressionToken, MshExpression>(); } ScriptBlock scriptBlock = ScriptBlock.Create(et.expressionValue); scriptBlock.DebuggerStepThrough = true; if ((loadingInfo != null) && loadingInfo.isFullyTrusted) { scriptBlock.LanguageMode = 0; } MshExpression expression2 = new MshExpression(scriptBlock); this._expressionCache.Add(et, expression2); return(expression2); }
private int MatchTypeIndex(string typeName, PSObject currentObject, MshExpression ex) { if (string.IsNullOrEmpty(typeName)) { return(-1); } int num = 0; foreach (string a in this._typeNameHierarchy) { if (string.Equals(a, typeName, StringComparison.OrdinalIgnoreCase) && this.MatchCondition(currentObject, ex)) { return(num); } if (num == 0) { if (!this._useInheritance) { break; } } ++num; } return(-1); }
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); }
internal static List<MshResolvedExpressionParameterAssociation> ExpandAll(PSObject target) { List<string> propertyNamesFromView = GetPropertyNamesFromView(target, PSMemberViewTypes.Adapted); List<string> list2 = GetPropertyNamesFromView(target, PSMemberViewTypes.Base); List<string> collection = GetPropertyNamesFromView(target, PSMemberViewTypes.Extended); List<string> list4 = new List<string>(); if (propertyNamesFromView.Count != 0) { list4 = propertyNamesFromView; } else { list4 = list2; } list4.AddRange(collection); Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); List<MshResolvedExpressionParameterAssociation> list5 = new List<MshResolvedExpressionParameterAssociation>(); foreach (string str in list4) { if (!dictionary.ContainsKey(str)) { dictionary.Add(str, null); MshExpression expression = new MshExpression(str, true); list5.Add(new MshResolvedExpressionParameterAssociation(null, expression)); } } return list5; }
private void InitializeGroupBy() { if ((this.parameters != null) && (this.parameters.groupByParameter != null)) { MshExpression entry = this.parameters.groupByParameter.GetEntry("expression") as MshExpression; string displayLabel = null; object obj2 = this.parameters.groupByParameter.GetEntry("label"); if (obj2 != AutomationNull.Value) { displayLabel = obj2 as string; } this.groupingManager = new GroupingInfoManager(); this.groupingManager.Initialize(entry, displayLabel); } else if (this.dataBaseInfo.view != null) { GroupBy groupBy = this.dataBaseInfo.view.groupBy; if ((groupBy != null) && ((groupBy.startGroup != null) && (groupBy.startGroup.expression != null))) { MshExpression groupingExpression = this.expressionFactory.CreateFromExpressionToken(groupBy.startGroup.expression, this.dataBaseInfo.view.loadingInfo); this.groupingManager = new GroupingInfoManager(); this.groupingManager.Initialize(groupingExpression, null); } } }
internal static MshExpression GetDisplayNameExpression( PSObject target, MshExpressionFactory expressionFactory) { MshExpression defaultNameExpression = PSObjectHelper.GetDefaultNameExpression(target); if (defaultNameExpression != null) { return(defaultNameExpression); } string[] strArray = new string[6] { "name", "id", "key", "*key", "*name", "*id" }; foreach (string s in strArray) { List <MshExpression> mshExpressionList = new MshExpression(s).ResolveNames(target); while (mshExpressionList.Count > 0 && (mshExpressionList[0].ToString().Equals(RemotingConstants.ComputerNameNoteProperty, StringComparison.OrdinalIgnoreCase) || mshExpressionList[0].ToString().Equals(RemotingConstants.ShowComputerNameNoteProperty, StringComparison.OrdinalIgnoreCase) || mshExpressionList[0].ToString().Equals(RemotingConstants.RunspaceIdNoteProperty, StringComparison.OrdinalIgnoreCase))) { mshExpressionList.RemoveAt(0); } if (mshExpressionList.Count != 0) { return(mshExpressionList[0]); } } return((MshExpression)null); }
internal override object Verify(object val, TerminatingErrorContext invocationContext, bool originalParameterWasHashTable) { if (val == null) { throw PSTraceSource.NewArgumentNullException("val"); } ScriptBlock scriptBlock = val as ScriptBlock; if (scriptBlock != null) { return new MshExpression(scriptBlock); } string str = val as string; if (str != null) { if (string.IsNullOrEmpty(str)) { this.ProcessEmptyStringError(originalParameterWasHashTable, invocationContext); } MshExpression expression2 = new MshExpression(str); if (this._noGlobbing && expression2.HasWildCardCharacters) { this.ProcessGlobbingCharactersError(originalParameterWasHashTable, str, invocationContext); } return expression2; } PSTraceSource.NewArgumentException("val"); return null; }
internal static List <MshResolvedExpressionParameterAssociation> ExpandAll(PSObject target) { List <string> propertyNamesFromView = GetPropertyNamesFromView(target, PSMemberViewTypes.Adapted); List <string> list2 = GetPropertyNamesFromView(target, PSMemberViewTypes.Base); List <string> collection = GetPropertyNamesFromView(target, PSMemberViewTypes.Extended); List <string> list4 = new List <string>(); if (propertyNamesFromView.Count != 0) { list4 = propertyNamesFromView; } else { list4 = list2; } list4.AddRange(collection); Dictionary <string, object> dictionary = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase); List <MshResolvedExpressionParameterAssociation> list5 = new List <MshResolvedExpressionParameterAssociation>(); foreach (string str in list4) { if (!dictionary.ContainsKey(str)) { dictionary.Add(str, null); MshExpression expression = new MshExpression(str, true); list5.Add(new MshResolvedExpressionParameterAssociation(null, expression)); } } return(list5); }
internal override object Verify(object val, TerminatingErrorContext invocationContext, bool originalParameterWasHashTable) { if (val == null) { throw PSTraceSource.NewArgumentNullException("val"); } ScriptBlock scriptBlock = val as ScriptBlock; if (scriptBlock != null) { return(new MshExpression(scriptBlock)); } string str = val as string; if (str != null) { if (string.IsNullOrEmpty(str)) { this.ProcessEmptyStringError(originalParameterWasHashTable, invocationContext); } MshExpression expression2 = new MshExpression(str); if (this._noGlobbing && expression2.HasWildCardCharacters) { this.ProcessGlobbingCharactersError(originalParameterWasHashTable, str, invocationContext); } return(expression2); } PSTraceSource.NewArgumentException("val"); return(null); }
internal MshExpression CreateFromExpressionToken(ExpressionToken et, DatabaseLoadingInfo loadingInfo) { if (!et.isScriptBlock) { return new MshExpression(et.expressionValue); } if (this._expressionCache != null) { MshExpression expression; if (this._expressionCache.TryGetValue(et, out expression)) { return expression; } } else { this._expressionCache = new Dictionary<ExpressionToken, MshExpression>(); } ScriptBlock scriptBlock = ScriptBlock.Create(et.expressionValue); scriptBlock.DebuggerStepThrough = true; if ((loadingInfo != null) && loadingInfo.isFullyTrusted) { scriptBlock.LanguageMode = 0; } MshExpression expression2 = new MshExpression(scriptBlock); this._expressionCache.Add(et, expression2); return expression2; }
private int ComputeBestMatch(AppliesTo appliesTo, PSObject currentObject) { int num1 = -1; foreach (TypeOrGroupReference reference in appliesTo.referenceList) { MshExpression ex = (MshExpression)null; if (reference.conditionToken != null) { ex = this._expressionFactory.CreateFromExpressionToken(reference.conditionToken); } int num2 = -1; if (reference is TypeReference typeReference) { num2 = this.MatchTypeIndex(typeReference.name, currentObject, ex); } else { TypeGroupDefinition groupDefinition = DisplayDataQuery.FindGroupDefinition(this._db, (reference as TypeGroupReference).name); if (groupDefinition != null) { num2 = this.ComputeBestMatchInGroup(groupDefinition, currentObject, ex); } } if (num2 == 0) { return(num2); } if (num1 == -1 || num1 < num2) { num1 = num2; } } return(num1); }
private static int ComputeDefaultAlignment(PSObject so, MshExpression ex) { List <MshExpressionResult> rList = ex.GetValues(so); if ((rList.Count == 0) || (rList[0].Exception != null)) { return(TextAlignment.Left); } object val = rList[0].Result; if (val == null) { return(TextAlignment.Left); } PSObject soVal = PSObject.AsPSObject(val); var typeNames = soVal.InternalTypeNames; if (string.Equals(PSObjectHelper.PSObjectIsOfExactType(typeNames), "System.String", StringComparison.OrdinalIgnoreCase)) { return(TextAlignment.Left); } if (DefaultScalarTypes.IsTypeInList(typeNames)) { return(TextAlignment.Right); } return(TextAlignment.Left); }
private void SetUpActiveProperty(PSObject so) { List <MshParameter> parameters = null; if (base.inputParameters != null) { parameters = base.inputParameters.mshParameterList; } if ((parameters != null) && (parameters.Count > 0)) { base.activeAssociationList = AssociationManager.ExpandParameters(parameters, so); } else { MshExpression displayNameExpression = PSObjectHelper.GetDisplayNameExpression(so, base.expressionFactory); if (displayNameExpression != null) { base.activeAssociationList = new List <MshResolvedExpressionParameterAssociation>(); base.activeAssociationList.Add(new MshResolvedExpressionParameterAssociation(null, displayNameExpression)); } else { base.activeAssociationList = AssociationManager.ExpandDefaultPropertySet(so, base.expressionFactory); if (base.activeAssociationList.Count <= 0) { base.activeAssociationList = AssociationManager.ExpandAll(so); } } } }
internal MshResolvedExpressionParameterAssociation(MshParameter parameter, MshExpression expression) { if (expression == null) throw PSTraceSource.NewArgumentNullException("expression"); OriginatingParameter = parameter; ResolvedExpression = expression; }
private ListViewEntry GenerateListViewEntryFromDataBaseInfo(PSObject so, int enumerationLimit) { ListViewEntry lve = new ListViewEntry(); ListControlEntryDefinition activeListControlEntryDefinition = GetActiveListControlEntryDefinition(_listBody, so); foreach (ListControlItemDefinition listItem in activeListControlEntryDefinition.itemDefinitionList) { if (!EvaluateDisplayCondition(so, listItem.conditionToken)) { continue; } ListViewField lvf = new ListViewField(); MshExpressionResult result; lvf.formatPropertyField = GenerateFormatPropertyField(listItem.formatTokenList, so, enumerationLimit, out result); // we need now to provide a label if (listItem.label != null) { // if the directive provides one, we use it lvf.label = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(listItem.label); } else if (result != null) { // if we got a valid match from the Mshexpression, use it as a label lvf.label = result.ResolvedExpression.ToString(); } else { // we did fail getting a result (i.e. property does not exist on the object) // we try to fall back and see if we have an un-resolved MshExpression FormatToken token = listItem.formatTokenList[0]; FieldPropertyToken fpt = token as FieldPropertyToken; if (fpt != null) { MshExpression ex = this.expressionFactory.CreateFromExpressionToken(fpt.expression, this.dataBaseInfo.view.loadingInfo); // use the un-resolved MshExpression string as a label lvf.label = ex.ToString(); } else { TextToken tt = token as TextToken; if (tt != null) { // we had a text token, use it as a label (last resort...) lvf.label = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(tt); } } } lve.listViewFieldList.Add(lvf); } return(lve); }
private static MshExpression GetDefaultNameExpression(PSObject so) { MshExpression defaultNameExpression = GetDefaultNameExpression(so.PSStandardMembers); if (defaultNameExpression == null) { defaultNameExpression = GetDefaultNameExpression(MaskDeserializedAndGetStandardMembers(so)); } return(defaultNameExpression); }
internal bool IsMatch(MshExpression expression) { for (int i = 0; i < this._wildcardPatterns.Length; i++) { if (this._wildcardPatterns[i].IsMatch(expression.ToString())) { return true; } } return false; }
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 static MshExpressionResult GetDisplayName( PSObject target, MshExpressionFactory expressionFactory) { MshExpression displayNameExpression = PSObjectHelper.GetDisplayNameExpression(target, expressionFactory); if (displayNameExpression == null) { return((MshExpressionResult)null); } List <MshExpressionResult> values = displayNameExpression.GetValues(target); return(values.Count == 0 || values[0].Exception != null ? (MshExpressionResult)null : values[0]); }
internal static MshExpressionResult GetDisplayName(PSObject target, MshExpressionFactory expressionFactory) { MshExpression displayNameExpression = GetDisplayNameExpression(target, expressionFactory); if (displayNameExpression != null) { List <MshExpressionResult> values = displayNameExpression.GetValues(target); if ((values.Count != 0) && (values[0].Exception == null)) { return(values[0]); } } return(null); }
internal static List <MshResolvedExpressionParameterAssociation> ExpandParameters(List <MshParameter> parameters, PSObject target) { List <MshResolvedExpressionParameterAssociation> list = new List <MshResolvedExpressionParameterAssociation>(); foreach (MshParameter parameter in parameters) { MshExpression entry = parameter.GetEntry("expression") as MshExpression; foreach (MshExpression expression2 in entry.ResolveNames(target)) { list.Add(new MshResolvedExpressionParameterAssociation(parameter, expression2)); } } return(list); }
private bool MatchCondition(PSObject currentObject, MshExpression ex) { if (ex == null) { return(true); } MshExpressionResult expressionResult; bool flag = DisplayCondition.Evaluate(currentObject, ex, out expressionResult); if (expressionResult != null && expressionResult.Exception != null) { this._failedResultsList.Add(expressionResult); } return(flag); }
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 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 int ComputeBestMatch(AppliesTo appliesTo, PSObject currentObject) { int best = BestMatchIndexUndefined; foreach (TypeOrGroupReference r in appliesTo.referenceList) { MshExpression ex = null; if (r.conditionToken != null) { ex = _expressionFactory.CreateFromExpressionToken(r.conditionToken); } int currentMatch = BestMatchIndexUndefined; TypeReference tr = r as TypeReference; if (tr != null) { // we have a type currentMatch = MatchTypeIndex(tr.name, currentObject, ex); } else { // we have a type group reference TypeGroupReference tgr = r as TypeGroupReference; // find the type group definition the reference points to TypeGroupDefinition tgd = DisplayDataQuery.FindGroupDefinition(_db, tgr.name); if (tgd != null) { // we found the group, see if the group has the type currentMatch = ComputeBestMatchInGroup(tgd, currentObject, ex); } } if (currentMatch == BestMatchIndexPerfect) { return(currentMatch); } if (best == BestMatchIndexUndefined || best < currentMatch) { best = currentMatch; } } return(best); }
/// <summary> /// create an expression from an expression token /// </summary> /// <param name="et">expression token to use</param> /// <param name="loadingInfo">The context from which the file was loaded</param> /// <returns>constructed expression</returns> /// <exception cref="ParseException"></exception> internal MshExpression CreateFromExpressionToken(ExpressionToken et, DatabaseLoadingInfo loadingInfo) { if (et.isScriptBlock) { // we cache script blocks from expression tokens if (_expressionCache != null) { MshExpression value; if (_expressionCache.TryGetValue(et, out value)) { // got a hit on the cache, just return return(value); } } else { _expressionCache = new Dictionary <ExpressionToken, MshExpression>(); } bool isFullyTrusted = false; bool isProductCode = false; if (loadingInfo != null) { isFullyTrusted = loadingInfo.isFullyTrusted; isProductCode = loadingInfo.isProductCode; } // no hit, we build one and we cache ScriptBlock sb = ScriptBlock.CreateDelayParsedScriptBlock(et.expressionValue, isProductCode: isProductCode); sb.DebuggerStepThrough = true; if (isFullyTrusted) { sb.LanguageMode = PSLanguageMode.FullLanguage; } MshExpression ex = new MshExpression(sb); _expressionCache.Add(et, ex); return(ex); } // we do not cache if it is just a property name return(new MshExpression(et.expressionValue)); }
internal static List <MshResolvedExpressionParameterAssociation> ExpandParameters(List <MshParameter> parameters, PSObject target) { List <MshResolvedExpressionParameterAssociation> retVal = new List <MshResolvedExpressionParameterAssociation>(); foreach (MshParameter par in parameters) { MshExpression expression = par.GetEntry(FormatParameterDefinitionKeys.ExpressionEntryKey) as MshExpression; List <MshExpression> expandedExpressionList = expression.ResolveNames(target); foreach (MshExpression ex in expandedExpressionList) { retVal.Add(new MshResolvedExpressionParameterAssociation(par, ex)); } } return(retVal); }
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); }
private bool EvaluateDisplayCondition(PSObject so, ExpressionToken conditionToken) { if (conditionToken == null) { return(true); } MshExpression ex = _expressionFactory.CreateFromExpressionToken(conditionToken, _loadingInfo); MshExpressionResult expressionResult; bool retVal = DisplayCondition.Evaluate(so, ex, out expressionResult); if (expressionResult != null && expressionResult.Exception != null) { _errorManager.LogMshExpressionFailedResult(expressionResult, so); } return(retVal); }
private bool EvaluateDisplayCondition(PSObject so, ExpressionToken conditionToken) { MshExpressionResult result; if (conditionToken == null) { return(true); } MshExpression ex = this.expressionFactory.CreateFromExpressionToken(conditionToken, this.loadingInfo); bool flag = DisplayCondition.Evaluate(so, ex, out result); if ((result != null) && (result.Exception != null)) { this.errorManager.LogMshExpressionFailedResult(result, so); } return(flag); }
/// <summary> /// Retrieve the display name. It looks for a well known property and, /// if not found, it uses some heuristics to get a "close" match /// </summary> /// <param name="target">shell object to process</param> /// <param name="expressionFactory">expression factory to create MshExpression</param> /// <returns>resolved MshExpression; null if no match was found</returns> internal static MshExpression GetDisplayNameExpression(PSObject target, MshExpressionFactory expressionFactory) { // first try to get the expression from the object (types.ps1xml data) MshExpression expressionFromObject = GetDefaultNameExpression(target); if (expressionFromObject != null) { return(expressionFromObject); } // we failed the default display name, let's try some well known names // trying to get something potentially useful string[] knownPatterns = new string[] { "name", "id", "key", "*key", "*name", "*id", }; // go over the patterns, looking for the first match foreach (string pattern in knownPatterns) { MshExpression ex = new MshExpression(pattern); List <MshExpression> exprList = ex.ResolveNames(target); while ((exprList.Count > 0) && ( exprList[0].ToString().Equals(RemotingConstants.ComputerNameNoteProperty, StringComparison.OrdinalIgnoreCase) || exprList[0].ToString().Equals(RemotingConstants.ShowComputerNameNoteProperty, StringComparison.OrdinalIgnoreCase) || exprList[0].ToString().Equals(RemotingConstants.RunspaceIdNoteProperty, StringComparison.OrdinalIgnoreCase) || exprList[0].ToString().Equals(RemotingConstants.SourceJobInstanceId, StringComparison.OrdinalIgnoreCase))) { exprList.RemoveAt(0); } if (exprList.Count == 0) { continue; } // if more than one match, just return the first one return(exprList[0]); } // we did not find anything return(null); }
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 static List <MshResolvedExpressionParameterAssociation> ExpandTableParameters(List <MshParameter> parameters, PSObject target) { List <MshResolvedExpressionParameterAssociation> list = new List <MshResolvedExpressionParameterAssociation>(); foreach (MshParameter parameter in parameters) { MshExpression entry = parameter.GetEntry("expression") as MshExpression; List <MshExpression> list2 = entry.ResolveNames(target); if (!entry.HasWildCardCharacters && (list2.Count == 0)) { list.Add(new MshResolvedExpressionParameterAssociation(parameter, entry)); } foreach (MshExpression expression2 in list2) { list.Add(new MshResolvedExpressionParameterAssociation(parameter, expression2)); } } return(list); }
private int ComputeBestMatchInGroup(TypeGroupDefinition tgd, PSObject currentObject, MshExpression ex) { int num = -1; int num2 = 0; foreach (TypeReference reference in tgd.typeReferenceList) { int num3 = this.MatchTypeIndex(reference.name, currentObject, ex); if (num3 == 0) { return num3; } if ((num == -1) || (num < num3)) { num = num3; } num2++; } return num; }
/// <summary> /// it gets the display name value /// </summary> /// <param name="target">shell object to process</param> /// <param name="expressionFactory">expression factory to create MshExpression</param> /// <returns>MshExpressionResult if successful; null otherwise</returns> internal static MshExpressionResult GetDisplayName(PSObject target, MshExpressionFactory expressionFactory) { // get the expression to evaluate MshExpression ex = GetDisplayNameExpression(target, expressionFactory); if (ex == null) { return(null); } // evaluate the expression List <MshExpressionResult> resList = ex.GetValues(target); if (resList.Count == 0 || resList[0].Exception != null) { // no results or the retrieval on the first one failed return(null); } // return something only if the first match was successful return(resList[0]); }
private static int ComputeDefaultAlignment(PSObject so, MshExpression ex) { List<MshExpressionResult> values = ex.GetValues(so); if ((values.Count != 0) && (values[0].Exception == null)) { object result = values[0].Result; if (result != null) { ConsolidatedString internalTypeNames = PSObject.AsPSObject(result).InternalTypeNames; if (string.Equals(PSObjectHelper.PSObjectIsOfExactType(internalTypeNames), "System.String", StringComparison.OrdinalIgnoreCase)) { return 1; } if (DefaultScalarTypes.IsTypeInList(internalTypeNames)) { return 3; } } } return 1; }
internal override object Verify(object val, TerminatingErrorContext invocationContext, bool originalParameterWasHashTable) { if (val == null) { throw PSTraceSource.NewArgumentNullException("val"); } // need to check the type: // it can be a string or a script block ScriptBlock sb = val as ScriptBlock; if (sb != null) { MshExpression ex = new MshExpression(sb); return(ex); } string s = val as string; if (s != null) { if (string.IsNullOrEmpty(s)) { ProcessEmptyStringError(originalParameterWasHashTable, invocationContext); } MshExpression ex = new MshExpression(s); if (_noGlobbing) { if (ex.HasWildCardCharacters) { ProcessGlobbingCharactersError(originalParameterWasHashTable, s, invocationContext); } } return(ex); } PSTraceSource.NewArgumentException("val"); return(null); }
private int ComputeBestMatchInGroup(TypeGroupDefinition tgd, PSObject currentObject, MshExpression ex) { int best = BestMatchIndexUndefined; int k = 0; foreach (TypeReference tr in tgd.typeReferenceList) { int currentMatch = MatchTypeIndex(tr.name, currentObject, ex); if (currentMatch == BestMatchIndexPerfect) return currentMatch; if (best == BestMatchIndexUndefined || best < currentMatch) { best = currentMatch; } k++; } return best; }
private bool MatchCondition(PSObject currentObject, MshExpression ex) { MshExpressionResult result; if (ex == null) { return true; } bool flag = DisplayCondition.Evaluate(currentObject, ex, out result); if ((result != null) && (result.Exception != null)) { this._failedResultsList.Add(result); } return flag; }
/// <summary> /// Initialize with the grouping property data /// </summary> /// <param name="groupingExpression">name of the grouping property</param> /// <param name="displayLabel">display name of the property</param> internal void Initialize(MshExpression groupingExpression, string displayLabel) { _groupingKeyExpression = groupingExpression; _label = displayLabel; }
internal MshExpressionResult(object res, MshExpression re, System.Exception e) { this._result = res; this._resolvedExpression = re; this._exception = e; }
private int MatchTypeIndex(string typeName, PSObject currentObject, MshExpression ex) { if (!string.IsNullOrEmpty(typeName)) { int num = 0; foreach (string str in this._typeNameHierarchy) { if (string.Equals(str, typeName, StringComparison.OrdinalIgnoreCase) && this.MatchCondition(currentObject, ex)) { return num; } if ((num == 0) && !this._useInheritance) { break; } num++; } } return -1; }
internal ExpressionColumnInfo(string staleObjectPropertyName, string displayName, MshExpression expression) : base(staleObjectPropertyName, displayName) { _expression = expression; }
internal static List<MshResolvedExpressionParameterAssociation> ExpandAll(PSObject target) { List<string> adaptedProperties = GetPropertyNamesFromView(target, PSMemberViewTypes.Adapted); List<string> baseProperties = GetPropertyNamesFromView(target, PSMemberViewTypes.Base); List<string> extendedProperties = GetPropertyNamesFromView(target, PSMemberViewTypes.Extended); var displayedProperties = adaptedProperties.Count != 0 ? adaptedProperties : baseProperties; displayedProperties.AddRange(extendedProperties); Dictionary<string, object> duplicatesFinder = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); List<MshResolvedExpressionParameterAssociation> retVal = new List<MshResolvedExpressionParameterAssociation>(); foreach (string property in displayedProperties) { if (!duplicatesFinder.ContainsKey(property)) { duplicatesFinder.Add(property, null); MshExpression expr = new MshExpression(property, true); retVal.Add(new MshResolvedExpressionParameterAssociation(null, expr)); } } return retVal; }
/// <summary> /// Retrieve the display name. It looks for a well known property and, /// if not found, it uses some heuristics to get a "close" match /// </summary> /// <param name="target">shell object to process</param> /// <param name="expressionFactory">expression factory to create MshExpression</param> /// <returns>resolved MshExpression; null if no match was found</returns> internal static MshExpression GetDisplayNameExpression(PSObject target, MshExpressionFactory expressionFactory) { // first try to get the expression from the object (types.ps1xml data) MshExpression expressionFromObject = GetDefaultNameExpression(target); if (expressionFromObject != null) { return expressionFromObject; } // we failed the default display name, let's try some well known names // trying to get something potentially useful string[] knownPatterns = new string[] { "name", "id", "key", "*key", "*name", "*id", }; // go over the patterns, looking for the first match foreach (string pattern in knownPatterns) { MshExpression ex = new MshExpression(pattern); List<MshExpression> exprList = ex.ResolveNames(target); while ((exprList.Count > 0) && ( exprList[0].ToString().Equals(RemotingConstants.ComputerNameNoteProperty, StringComparison.OrdinalIgnoreCase) || exprList[0].ToString().Equals(RemotingConstants.ShowComputerNameNoteProperty, StringComparison.OrdinalIgnoreCase) || exprList[0].ToString().Equals(RemotingConstants.RunspaceIdNoteProperty, StringComparison.OrdinalIgnoreCase) || exprList[0].ToString().Equals(RemotingConstants.SourceJobInstanceId, StringComparison.OrdinalIgnoreCase))) { exprList.RemoveAt(0); } if (exprList.Count == 0) continue; // if more than one match, just return the first one return exprList[0]; } // we did not find anything return null; }
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; }
internal override object Verify(object val, TerminatingErrorContext invocationContext, bool originalParameterWasHashTable) { if (val == null) { throw PSTraceSource.NewArgumentNullException("val"); } // need to check the type: // it can be a string or a script block ScriptBlock sb = val as ScriptBlock; if (sb != null) { MshExpression ex = new MshExpression(sb); return ex; } string s = val as string; if (s != null) { if (string.IsNullOrEmpty(s)) { ProcessEmptyStringError(originalParameterWasHashTable, invocationContext); } MshExpression ex = new MshExpression(s); if (_noGlobbing) { if (ex.HasWildCardCharacters) ProcessGlobbingCharactersError(originalParameterWasHashTable, s, invocationContext); } return ex; } PSTraceSource.NewArgumentException("val"); return null; }
internal MshExpressionResult(object res, MshExpression re, Exception e) { Result = res; ResolvedExpression = re; Exception = e; }
internal List<MshExpression> ResolveNames(PSObject target, bool expand) { List<MshExpression> retVal = new List<MshExpression>(); if (_isResolved) { retVal.Add(this); return retVal; } if (Script != null) { // script block, just add it to the list and be done MshExpression ex = new MshExpression(Script); ex._isResolved = true; retVal.Add(ex); return retVal; } // we have a string value IEnumerable<PSMemberInfo> members = null; if (HasWildCardCharacters) { // get the members first: this will expand the globbing on each parameter members = target.Members.Match(_stringValue, PSMemberTypes.Properties | PSMemberTypes.PropertySet); } else { // we have no globbing: try an exact match, because this is quicker. PSMemberInfo x = target.Members[_stringValue]; List<PSMemberInfo> temp = new List<PSMemberInfo>(); if (x != null) { temp.Add(x); } members = temp; } // we now have a list of members, we have to expand property sets // and remove duplicates List<PSMemberInfo> temporaryMemberList = new List<PSMemberInfo>(); foreach (PSMemberInfo member in members) { // it can be a property set PSPropertySet propertySet = member as PSPropertySet; if (propertySet != null) { if (expand) { // NOTE: we expand the property set under the // assumption that it contains property names that // do not require any further expansion Collection<string> references = propertySet.ReferencedPropertyNames; for (int j = 0; j < references.Count; j++) { ReadOnlyPSMemberInfoCollection<PSPropertyInfo> propertyMembers = target.Properties.Match(references[j]); for (int jj = 0; jj < propertyMembers.Count; jj++) { temporaryMemberList.Add(propertyMembers[jj]); } } } continue; } // it can be a property if (member is PSPropertyInfo) { temporaryMemberList.Add(member); } } Hashtable hash = new Hashtable(); // build the list of unique values: remove the possible duplicates // from property set expansion foreach (PSMemberInfo m in temporaryMemberList) { if (!hash.ContainsKey(m.Name)) { MshExpression ex = new MshExpression(m.Name); ex._isResolved = true; retVal.Add(ex); hash.Add(m.Name, null); } } return retVal; }
/// <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); }
private int MatchTypeIndex(string typeName, PSObject currentObject, MshExpression ex) { if (string.IsNullOrEmpty(typeName)) return BestMatchIndexUndefined; int k = 0; foreach (string name in _typeNameHierarchy) { if (string.Equals(name, typeName, StringComparison.OrdinalIgnoreCase) && MatchCondition(currentObject, ex)) { return k; } if (k == 0 && !_useInheritance) break; k++; } return BestMatchIndexUndefined; }
private static int ComputeDefaultAlignment(PSObject so, MshExpression ex) { List<MshExpressionResult> rList = ex.GetValues(so); if ((rList.Count == 0) || (rList[0].Exception != null)) return TextAlignment.Left; object val = rList[0].Result; if (val == null) return TextAlignment.Left; PSObject soVal = PSObject.AsPSObject(val); var typeNames = soVal.InternalTypeNames; if (string.Equals(PSObjectHelper.PSObjectIsOfExactType(typeNames), "System.String", StringComparison.OrdinalIgnoreCase)) return TextAlignment.Left; if (DefaultScalarTypes.IsTypeInList(typeNames)) return TextAlignment.Right; return TextAlignment.Left; }
private bool MatchCondition(PSObject currentObject, MshExpression ex) { if (ex == null) return true; MshExpressionResult expressionResult; bool retVal = DisplayCondition.Evaluate(currentObject, ex, out expressionResult); if (expressionResult != null && expressionResult.Exception != null) { _failedResultsList.Add(expressionResult); } return retVal; }
protected string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex, FieldFormattingDirective directive) { MshExpressionResult resolvedExpression; return GetExpressionDisplayValue(so, enumerationLimit, ex, directive, out resolvedExpression); }
internal List<MshExpression> ResolveNames(PSObject target, bool expand) { List<MshExpression> list = new List<MshExpression>(); if (this._isResolved) { list.Add(this); return list; } if (this._script != null) { MshExpression item = new MshExpression(this._script) { _isResolved = true }; list.Add(item); return list; } IEnumerable<PSMemberInfo> enumerable = null; if (this.HasWildCardCharacters) { enumerable = target.Members.Match(this._stringValue, PSMemberTypes.PropertySet | PSMemberTypes.Properties); } else { PSMemberInfo info = target.Members[this._stringValue]; List<PSMemberInfo> list2 = new List<PSMemberInfo>(); if (info != null) { list2.Add(info); } enumerable = list2; } List<PSMemberInfo> list3 = new List<PSMemberInfo>(); foreach (PSMemberInfo info2 in enumerable) { PSPropertySet set = info2 as PSPropertySet; if (set != null) { if (expand) { Collection<string> referencedPropertyNames = set.ReferencedPropertyNames; for (int i = 0; i < referencedPropertyNames.Count; i++) { ReadOnlyPSMemberInfoCollection<PSPropertyInfo> infos = target.Properties.Match(referencedPropertyNames[i]); for (int j = 0; j < infos.Count; j++) { list3.Add(infos[j]); } } } } else if (info2 is PSPropertyInfo) { list3.Add(info2); } } Hashtable hashtable = new Hashtable(); foreach (PSMemberInfo info3 in list3) { if (!hashtable.ContainsKey(info3.Name)) { MshExpression expression2 = new MshExpression(info3.Name) { _isResolved = true }; list.Add(expression2); hashtable.Add(info3.Name, null); } } return list; }
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 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> /// create an expression from an expression token /// </summary> /// <param name="et">expression token to use</param> /// <param name="loadingInfo">The context from which the file was loaded</param> /// <returns>constructed expression</returns> /// <exception cref="ParseException"></exception> internal MshExpression CreateFromExpressionToken(ExpressionToken et, DatabaseLoadingInfo loadingInfo) { if (et.isScriptBlock) { // we cache script blocks from expression tokens if (_expressionCache != null) { MshExpression value; if (_expressionCache.TryGetValue(et, out value)) { // got a hit on the cache, just return return value; } } else { _expressionCache = new Dictionary<ExpressionToken, MshExpression>(); } bool isFullyTrusted = false; bool isProductCode = false; if (loadingInfo != null) { isFullyTrusted = loadingInfo.isFullyTrusted; isProductCode = loadingInfo.isProductCode; } // no hit, we build one and we cache ScriptBlock sb = ScriptBlock.CreateDelayParsedScriptBlock(et.expressionValue, isProductCode: isProductCode); sb.DebuggerStepThrough = true; if (isFullyTrusted) { sb.LanguageMode = PSLanguageMode.FullLanguage; } MshExpression ex = new MshExpression(sb); _expressionCache.Add(et, ex); return ex; } // we do not cache if it is just a property name return new MshExpression(et.expressionValue); }