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 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; }
private ExpressionToken LoadExpressionFromObjectModel(DisplayEntry displayEntry, int viewIndex, string typeName) { ExpressionToken token = new ExpressionToken(); if (displayEntry.ValueType.Equals(DisplayEntryValueType.Property)) { token.expressionValue = displayEntry.Value; return token; } if (displayEntry.ValueType.Equals(DisplayEntryValueType.ScriptBlock)) { token.isScriptBlock = true; token.expressionValue = displayEntry.Value; try { base.expressionFactory.VerifyScriptBlockText(token.expressionValue); } catch (ParseException exception) { base.ReportErrorForLoadingFromObjectModel(StringUtil.Format(FormatAndOutXmlLoadingStrings.InvalidScriptBlockInFormattingData, new object[] { typeName, viewIndex, exception.Message }), typeName); return null; } catch (Exception) { throw; } return token; } PSTraceSource.NewInvalidOperationException(); return null; }
internal bool ProcessExpressionDirectives(System.Xml.XmlNode containerNode, List<System.Xml.XmlNode> unprocessedNodes) { if (containerNode == null) { throw PSTraceSource.NewArgumentNullException("containerNode"); } string mandatoryInnerText = null; Microsoft.PowerShell.Commands.Internal.Format.TextToken token = null; TypeInfoDataBaseLoader.ExpressionNodeMatch match = new TypeInfoDataBaseLoader.ExpressionNodeMatch(this._loader); bool flag = false; bool flag2 = false; bool flag3 = false; foreach (System.Xml.XmlNode node in containerNode.ChildNodes) { if (match.MatchNode(node)) { if (flag2) { this._loader.ProcessDuplicateNode(node); return false; } flag2 = true; if (!match.ProcessNode(node)) { return false; } } else if (this._loader.MatchNodeName(node, "FormatString")) { if (flag) { this._loader.ProcessDuplicateNode(node); return false; } flag = true; mandatoryInnerText = this._loader.GetMandatoryInnerText(node); if (mandatoryInnerText == null) { this._loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.NoFormatString, this._loader.ComputeCurrentXPath(), this._loader.FilePath)); return false; } } else if (this._loader.MatchNodeNameWithAttributes(node, "Text")) { if (flag3) { this._loader.ProcessDuplicateNode(node); return false; } flag3 = true; token = this._loader.LoadText(node); if (token == null) { this._loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.InvalidNode, new object[] { this._loader.ComputeCurrentXPath(), this._loader.FilePath, "Text" })); return false; } } else { unprocessedNodes.Add(node); } } if (flag2) { if (flag3) { this._loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.NodeWithExpression, new object[] { this._loader.ComputeCurrentXPath(), this._loader.FilePath, "Text" })); return false; } ExpressionToken token2 = match.GenerateExpressionToken(); if (token2 == null) { return false; } if (!string.IsNullOrEmpty(mandatoryInnerText)) { this._formatString = mandatoryInnerText; } this._expression = token2; } else { if (flag) { this._loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.NodeWithoutExpression, new object[] { this._loader.ComputeCurrentXPath(), this._loader.FilePath, "FormatString" })); return false; } if (flag3) { this._textToken = token; } } return true; }
internal bool ProcessNode(System.Xml.XmlNode n) { if (this._loader.MatchNodeName(n, "PropertyName")) { if (this._token != null) { if (this._token.isScriptBlock) { this._loader.ProcessDuplicateAlternateNode(n, "PropertyName", "ScriptBlock"); } else { this._loader.ProcessDuplicateNode(n); } return false; } this._token = new ExpressionToken(); this._token.expressionValue = this._loader.GetMandatoryInnerText(n); if (this._token.expressionValue == null) { this._loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.NoProperty, this._loader.ComputeCurrentXPath(), this._loader.FilePath)); this._fatalError = true; return false; } return true; } if (this._loader.MatchNodeName(n, "ScriptBlock")) { if (this._token != null) { if (!this._token.isScriptBlock) { this._loader.ProcessDuplicateAlternateNode(n, "PropertyName", "ScriptBlock"); } else { this._loader.ProcessDuplicateNode(n); } return false; } this._token = new ExpressionToken(); this._token.isScriptBlock = true; this._token.expressionValue = this._loader.GetMandatoryInnerText(n); if (this._token.expressionValue == null) { this._loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.NoScriptBlockText, this._loader.ComputeCurrentXPath(), this._loader.FilePath)); this._fatalError = true; return false; } if (!this._loader.suppressValidation && !this._loader.VerifyScriptBlock(this._token.expressionValue)) { this._fatalError = true; return false; } return true; } PSTraceSource.NewInvalidOperationException(); return false; }
/// <summary> /// Load the expression information from DisplayEntry /// </summary> /// <param name="displayEntry"></param> /// <param name="viewIndex"></param> /// <param name="typeName"></param> /// <returns></returns> private ExpressionToken LoadExpressionFromObjectModel(DisplayEntry displayEntry, int viewIndex, string typeName) { ExpressionToken token = new ExpressionToken(); if (displayEntry.ValueType == DisplayEntryValueType.Property) { token.expressionValue = displayEntry.Value; return token; } else if (displayEntry.ValueType == DisplayEntryValueType.ScriptBlock) { token.isScriptBlock = true; token.expressionValue = displayEntry.Value; try { // For faster startup, we don't validate any of the built-in formatting script blocks, where isFullyTrusted == built-in. if (!LoadingInfo.isFullyTrusted) { this.expressionFactory.VerifyScriptBlockText(token.expressionValue); } } catch (ParseException e) { // Error at this.ReportErrorForLoadingFromObjectModel( StringUtil.Format(FormatAndOutXmlLoadingStrings.InvalidScriptBlockInFormattingData, typeName, viewIndex, e.Message), typeName); return null; } catch (Exception e) // will rethrow { Diagnostics.Assert(false, "TypeInfoBaseLoader.VerifyScriptBlock unexpected exception " + e.GetType().FullName); throw; } return token; } // this should never happen if the API is used correctly PSTraceSource.NewInvalidOperationException(); return null; }
internal bool ProcessNode(XmlNode n) { if (_loader.MatchNodeName(n, XmlTags.PropertyNameNode)) { if (_token != null) { if (_token.isScriptBlock) _loader.ProcessDuplicateAlternateNode(n, XmlTags.PropertyNameNode, XmlTags.ScriptBlockNode); else _loader.ProcessDuplicateNode(n); return false; // fatal error } _token = new ExpressionToken(); _token.expressionValue = _loader.GetMandatoryInnerText(n); if (_token.expressionValue == null) { //Error at XPath {0} in file {1}: Missing property. _loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.NoProperty, _loader.ComputeCurrentXPath(), _loader.FilePath)); _fatalError = true; return false; // fatal error } return true; } else if (_loader.MatchNodeName(n, XmlTags.ScriptBlockNode)) { if (_token != null) { if (!_token.isScriptBlock) _loader.ProcessDuplicateAlternateNode(n, XmlTags.PropertyNameNode, XmlTags.ScriptBlockNode); else _loader.ProcessDuplicateNode(n); return false; // fatal error } _token = new ExpressionToken(); _token.isScriptBlock = true; _token.expressionValue = _loader.GetMandatoryInnerText(n); if (_token.expressionValue == null) { //Error at XPath {0} in file {1}: Missing script block text. _loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.NoScriptBlockText, _loader.ComputeCurrentXPath(), _loader.FilePath)); _fatalError = true; return false; // fatal error } if ((!_loader._suppressValidation) && (!_loader.VerifyScriptBlock(_token.expressionValue))) { _fatalError = true; return false; // fatal error } return true; } // this should never happen if the API is used correctly PSTraceSource.NewInvalidOperationException(); return false; }
protected bool EvaluateDisplayCondition(PSObject so, ExpressionToken conditionToken) { if (conditionToken == null) return true; MshExpression ex = this.expressionFactory.CreateFromExpressionToken(conditionToken, this.dataBaseInfo.view.loadingInfo); MshExpressionResult expressionResult; bool retVal = DisplayCondition.Evaluate(so, ex, out expressionResult); if (expressionResult != null && expressionResult.Exception != null) { _errorManager.LogMshExpressionFailedResult(expressionResult, so); } return retVal; }
internal MshExpression CreateFromExpressionToken(ExpressionToken et) { return this.CreateFromExpressionToken(et, null); }
/// <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); }
/// <summary> /// Create an expression from an expression token. /// </summary> /// <param name="et">Expression token to use.</param> /// <returns>Constructed expression.</returns> /// <exception cref="ParseException"></exception> internal PSPropertyExpression CreateFromExpressionToken(ExpressionToken et) { return(CreateFromExpressionToken(et, null)); }
private bool LoadPropertyBaseHelper(XmlNode propertyBaseNode, PropertyTokenBase ptb, List <XmlNode> unprocessedNodes) { ExpressionNodeMatch expressionMatch = new ExpressionNodeMatch(this); bool expressionNodeFound = false; // cardinality 0..1 bool collectionNodeFound = false; // cardinality 0..1 bool itemSelectionConditionNodeFound = false; // cardinality 0..1 ExpressionToken condition = null; foreach (XmlNode n in propertyBaseNode.ChildNodes) { if (expressionMatch.MatchNode(n)) { if (expressionNodeFound) { this.ProcessDuplicateNode(n); return(false); // fatal error } expressionNodeFound = true; if (!expressionMatch.ProcessNode(n)) { return(false); // fatal error } } else if (MatchNodeName(n, XmlTags.EnumerateCollectionNode)) { if (collectionNodeFound) { this.ProcessDuplicateNode(n); return(false); } collectionNodeFound = true; if (!ReadBooleanNode(n, out ptb.enumerateCollection)) { return(false); } } else if (MatchNodeName(n, XmlTags.ItemSelectionConditionNode)) { if (itemSelectionConditionNodeFound) { this.ProcessDuplicateNode(n); return(false); } itemSelectionConditionNodeFound = true; condition = LoadItemSelectionCondition(n); if (condition is null) { return(false); } } else { if (!IsFilteredOutNode(n)) { unprocessedNodes.Add(n); } } } if (expressionNodeFound) { // we add only if we encountered one, since it's not mandatory ExpressionToken expression = expressionMatch.GenerateExpressionToken(); if (expression is null) { return(false); // fatal error } ptb.expression = expression; ptb.conditionToken = condition; } return(true); }
private ListControlItemDefinition LoadListControlItemDefinition(XmlNode propertyEntryNode) { using (this.StackFrame(propertyEntryNode)) { // process Mshexpression, format string and text token ViewEntryNodeMatch match = new ViewEntryNodeMatch(this); List <XmlNode> unprocessedNodes = new List <XmlNode>(); if (!match.ProcessExpressionDirectives(propertyEntryNode, unprocessedNodes)) { return(null); // fatal error } // process the remaining nodes TextToken labelToken = null; ExpressionToken condition = null; bool labelNodeFound = false; // cardinality 0..1 bool itemSelectionConditionNodeFound = false; // cardinality 0..1 foreach (XmlNode n in unprocessedNodes) { if (MatchNodeName(n, XmlTags.ItemSelectionConditionNode)) { if (itemSelectionConditionNodeFound) { this.ProcessDuplicateNode(n); return(null); // fatal error } itemSelectionConditionNodeFound = true; condition = LoadItemSelectionCondition(n); if (condition is null) { return(null); // fatal error } } else if (MatchNodeNameWithAttributes(n, XmlTags.LabelNode)) { if (labelNodeFound) { this.ProcessDuplicateNode(n); return(null); // fatal error } labelNodeFound = true; labelToken = LoadLabel(n); if (labelToken is null) { return(null); // fatal error } } else { this.ProcessUnknownNode(n); } } // finally build the item to return ListControlItemDefinition lvid = new ListControlItemDefinition(); // add the label lvid.label = labelToken; // add condition lvid.conditionToken = condition; // add either the text token or the PSPropertyExpression with optional format string if (match.TextToken != null) { lvid.formatTokenList.Add(match.TextToken); } else { FieldPropertyToken fpt = new FieldPropertyToken(); fpt.expression = match.Expression; fpt.fieldFormattingDirective.formatString = match.FormatString; lvid.formatTokenList.Add(fpt); } return(lvid); } }
/// <summary> /// create an expression from an expression token /// </summary> /// <param name="et">expression token to use</param> /// <returns>constructed expression</returns> /// <exception cref="ParseException"></exception> internal MshExpression CreateFromExpressionToken(ExpressionToken et) { return(CreateFromExpressionToken(et, null)); }