Example #1
0
 private static Collection<Attribute> GetAttributeCollection(AttributeBaseAst[] attributeAsts)
 {
     Collection<Attribute> collection = new Collection<Attribute>();
     foreach (AttributeBaseAst ast in attributeAsts)
     {
         collection.Add(ast.GetAttribute());
     }
     return collection;
 }
Example #2
0
 public AttributedExpressionAst(IScriptExtent extent, AttributeBaseAst attribute, ExpressionAst child) : base(extent)
 {
     if ((attribute == null) || (child == null))
     {
         throw PSTraceSource.NewArgumentNullException((attribute == null) ? "attribute" : "child");
     }
     this.Attribute = attribute;
     base.SetParent(attribute);
     this.Child = child;
     base.SetParent(child);
 }
Example #3
0
 public AttributedExpressionAst(IScriptExtent extent, AttributeBaseAst attribute, ExpressionAst child) : base(extent)
 {
     if ((attribute == null) || (child == null))
     {
         throw PSTraceSource.NewArgumentNullException((attribute == null) ? "attribute" : "child");
     }
     this.Attribute = attribute;
     base.SetParent(attribute);
     this.Child = child;
     base.SetParent(child);
 }
Example #4
0
        public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
        {
            AttributeBaseAst attribute = attributedExpressionAst.Attribute;

            while (attributedExpressionAst != null)
            {
                if (attributedExpressionAst.Child is VariableExpressionAst)
                {
                    return(AstVisitAction.Continue);
                }
                attributedExpressionAst = attributedExpressionAst.Child as AttributedExpressionAst;
            }
            this._parser.ReportError(attribute.Extent, ParserStrings.UnexpectedAttribute, new object[] { attribute.TypeName.FullName });
            return(AstVisitAction.Continue);
        }
 public AttributedExpressionAst(IScriptExtent extent, AttributeBaseAst attribute, ExpressionAst child)
     : base(extent)
 {
     this.Attribute = attribute;
     this.Child = child;
 }
Example #6
0
 private static object SetVariableValue(VariablePath variablePath, object value, ExecutionContext executionContext, AttributeBaseAst[] attributeAsts)
 {
     SessionStateScope scope;
     SessionStateInternal engineSessionState = executionContext.EngineSessionState;
     CommandOrigin scopeOrigin = engineSessionState.CurrentScope.ScopeOrigin;
     if (!variablePath.IsVariable)
     {
         engineSessionState.SetVariable(variablePath, value, true, scopeOrigin);
         return value;
     }
     if (executionContext.PSDebugTraceLevel > 0)
     {
         executionContext.Debugger.TraceVariableSet(variablePath.UnqualifiedPath, value);
     }
     if (variablePath.IsUnscopedVariable)
     {
         variablePath = variablePath.CloneAndSetLocal();
     }
     PSVariable newValue = engineSessionState.GetVariableItem(variablePath, out scope, scopeOrigin);
     if (newValue == null)
     {
         Collection<Attribute> attributes = (attributeAsts == null) ? new Collection<Attribute>() : GetAttributeCollection(attributeAsts);
         newValue = new PSVariable(variablePath.UnqualifiedPath, value, ScopedItemOptions.None, attributes);
         engineSessionState.SetVariable(variablePath, newValue, false, scopeOrigin);
         if (executionContext._debuggingMode > 0)
         {
             executionContext.Debugger.CheckVariableWrite(variablePath.UnqualifiedPath);
         }
         return value;
     }
     if (attributeAsts != null)
     {
         newValue.Attributes.Clear();
         Collection<Attribute> attributeCollection = GetAttributeCollection(attributeAsts);
         value = PSVariable.TransformValue(attributeCollection, value);
         if (!PSVariable.IsValidValue(attributeCollection, value))
         {
             ValidationMetadataException exception = new ValidationMetadataException("ValidateSetFailure", null, Metadata.InvalidValueFailure, new object[] { newValue.Name, (value != null) ? value.ToString() : "" });
             throw exception;
         }
         newValue.SetValueRaw(value, true);
         newValue.AddParameterAttributesNoChecks(attributeCollection);
         if (executionContext._debuggingMode > 0)
         {
             executionContext.Debugger.CheckVariableWrite(variablePath.UnqualifiedPath);
         }
         return value;
     }
     newValue.Value = value;
     return value;
 }
Example #7
0
 private static Collection<Attribute> GetAttributeCollection(AttributeBaseAst[] attributeAsts)
 {
     var result = new Collection<Attribute>();
     foreach (var attributeAst in attributeAsts)
     {
         result.Add(attributeAst.GetAttribute());
     }
     return result;
 }
Example #8
0
        internal static object SetVariableValue(VariablePath variablePath, object value, ExecutionContext executionContext, AttributeBaseAst[] attributeAsts)
        {
            SessionStateInternal sessionState = executionContext.EngineSessionState;
            CommandOrigin origin = sessionState.CurrentScope.ScopeOrigin;

            if (!variablePath.IsVariable)
            {
                sessionState.SetVariable(variablePath, value, true, origin);
                return value;
            }

            // Variable assignment is traced only if trace level 2 is specified.
            if (executionContext.PSDebugTraceLevel > 1)
            {
                executionContext.Debugger.TraceVariableSet(variablePath.UnqualifiedPath, value);
            }

            if (variablePath.IsUnscopedVariable)
            {
                variablePath = variablePath.CloneAndSetLocal();
            }

            SessionStateScope scope;
            PSVariable var = sessionState.GetVariableItem(variablePath, out scope, origin);

            if (var == null)
            {
                var attributes = attributeAsts == null
                                     ? new Collection<Attribute>()
                                     : GetAttributeCollection(attributeAsts);
                var = new PSVariable(variablePath.UnqualifiedPath, value, ScopedItemOptions.None, attributes);

                sessionState.SetVariable(variablePath, var, false, origin);

                if (executionContext._debuggingMode > 0)
                {
                    executionContext.Debugger.CheckVariableWrite(variablePath.UnqualifiedPath);
                }
            }
            else if (attributeAsts != null)
            {
                var.Attributes.Clear();
                var attributes = GetAttributeCollection(attributeAsts);
                value = PSVariable.TransformValue(attributes, value);
                if (!PSVariable.IsValidValue(attributes, value))
                {
                    ValidationMetadataException e = new ValidationMetadataException(
                        "ValidateSetFailure",
                        null,
                        Metadata.InvalidValueFailure,
                        var.Name,
                        ((value != null) ? value.ToString() : "$null"));

                    throw e;
                }
                var.SetValueRaw(value, true);
                var.AddParameterAttributesNoChecks(attributes);

                if (executionContext._debuggingMode > 0)
                {
                    executionContext.Debugger.CheckVariableWrite(variablePath.UnqualifiedPath);
                }
            }
            else
            {
                // The setter will handle checking for variable writes.
                var.Value = value;
            }

            return value;
        }
 public AttributedExpressionAst(IScriptExtent extent, AttributeBaseAst attribute, ExpressionAst child)
     : base(extent)
 {
     this.Attribute = attribute;
     this.Child     = child;
 }