internal PSVariable GetVariable(ExecutionContext context) { if (this._useConstantValue) { return((PSVariable)null); } SessionStateInternal engineSessionState = context.EngineSessionState; CommandOrigin scopeOrigin = engineSessionState.currentScope.ScopeOrigin; if (!this._variablePath.IsScopedItem) { SessionStateScope scope = (SessionStateScope)null; return(engineSessionState.GetVariableItem(this._variablePath, out scope, scopeOrigin)); } PSVariable variable = engineSessionState.CurrentActivationRecord.GetVariable(this._activationRecordSlot, scopeOrigin); if (variable == null) { SessionStateScope scope; variable = engineSessionState.GetVariableItem(this._variablePath, out scope, scopeOrigin); if (variable != null) { engineSessionState.CurrentActivationRecord.SetVariable(variable, scope, this._activationRecordSlot); } else if ((context.IsStrictVersion(2) || !this._inExpandableString && context.IsStrictVersion(1)) && !this.IsInternalCode) { throw InterpreterError.NewInterpreterException((object)this.NodeToken, typeof(RuntimeException), this.NodeToken, "VariableIsUndefined", (object)this.NodeToken); } } return(variable); }
internal static PSReference GetVariableAsRef(VariablePath variablePath, ExecutionContext executionContext, Type staticType) { Diagnostics.Assert(variablePath.IsVariable, "calller to verify varpath is a variable."); SessionStateInternal sessionState = executionContext.EngineSessionState; CommandOrigin origin = sessionState.CurrentScope.ScopeOrigin; SessionStateScope scope; PSVariable var = sessionState.GetVariableItem(variablePath, out scope, origin); if (var == null) { throw InterpreterError.NewInterpreterException(variablePath, typeof(RuntimeException), null, "NonExistingVariableReference", ParserStrings.NonExistingVariableReference); } object value = var.Value; if (staticType == null && value != null) { value = PSObject.Base(value); if (value != null) { staticType = value.GetType(); } } if (staticType == null) { var declaredType = var.Attributes.OfType <ArgumentTypeConverterAttribute>().FirstOrDefault(); staticType = declaredType != null ? declaredType.TargetType : typeof(LanguagePrimitives.Null); } return(PSReference.CreateInstance(var, staticType)); }
internal static object GetVariableValue(VariablePath variablePath, ExecutionContext executionContext, VariableExpressionAst varAst) { if (!variablePath.IsVariable) { CmdletProviderContext contextOut; SessionStateScope scopeOut; SessionStateInternal ss = executionContext.EngineSessionState; return(ss.GetVariableValueFromProvider(variablePath, out contextOut, out scopeOut, ss.CurrentScope.ScopeOrigin)); } SessionStateInternal sessionState = executionContext.EngineSessionState; CommandOrigin origin = sessionState.CurrentScope.ScopeOrigin; SessionStateScope scope; PSVariable var = sessionState.GetVariableItem(variablePath, out scope, origin); if (var != null) { return(var.Value); } if (sessionState.ExecutionContext._debuggingMode > 0) { sessionState.ExecutionContext.Debugger.CheckVariableRead(variablePath.UnqualifiedPath); } if (ThrowStrictModeUndefinedVariable(executionContext, varAst)) { throw InterpreterError.NewInterpreterException(variablePath.UserPath, typeof(RuntimeException), varAst.Extent, "VariableIsUndefined", ParserStrings.VariableIsUndefined, variablePath.UserPath); } return(null); }
private static PSReference GetVariableAsRef(VariablePath variablePath, ExecutionContext executionContext, Type staticType) { SessionStateScope scope; SessionStateInternal engineSessionState = executionContext.EngineSessionState; CommandOrigin scopeOrigin = engineSessionState.CurrentScope.ScopeOrigin; PSVariable variable = engineSessionState.GetVariableItem(variablePath, out scope, scopeOrigin); if (variable == null) { throw InterpreterError.NewInterpreterException(variablePath, typeof(RuntimeException), null, "NonExistingVariableReference", ParserStrings.NonExistingVariableReference, new object[0]); } object obj2 = variable.Value; if ((staticType == null) && (obj2 != null)) { obj2 = PSObject.Base(obj2); if (obj2 != null) { staticType = obj2.GetType(); } } if (staticType == null) { ArgumentTypeConverterAttribute attribute = variable.Attributes.OfType <ArgumentTypeConverterAttribute>().FirstOrDefault <ArgumentTypeConverterAttribute>(); staticType = (attribute != null) ? attribute.TargetType : typeof(LanguagePrimitives.Null); } return(PSReference.CreateInstance(variable, staticType)); }
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); }
private void PrivateSetValue(object value, ExecutionContext context) { SessionStateInternal engineSessionState = context.EngineSessionState; CommandOrigin scopeOrigin = engineSessionState.currentScope.ScopeOrigin; if (!this._variablePath.IsScopedItem) { engineSessionState.SetVariable(this._variablePath, value, true, scopeOrigin); } else { PSVariable variable1 = engineSessionState.CurrentActivationRecord.GetVariable(this._activationRecordSlot, scopeOrigin); if (variable1 != null) { this.UpdateVariable(variable1, value); } else { ScopedItemLookupPath variablePath = !this._variablePath.IsUnqualified ? this._variablePath : new ScopedItemLookupPath(this._variablePath, true); SessionStateScope scope; PSVariable variable2 = engineSessionState.GetVariableItem(variablePath, out scope, scopeOrigin); if (variable2 == null) { if (string.IsNullOrEmpty(variablePath.LookupPath.NamespaceSpecificString)) { throw InterpreterError.NewInterpreterException((object)this._varName, typeof(RuntimeException), this.NodeToken, "InvalidVariableReference"); } variable2 = new PSVariable(variablePath.LookupPath.NamespaceSpecificString, (object)null, ScopedItemOptions.None, new Collection <Attribute>()); engineSessionState.SetVariable(variablePath, (object)variable2, false, scopeOrigin); if (variablePath.IsLocal) { scope = context.EngineSessionState.CurrentScope; } } engineSessionState.CurrentActivationRecord.SetVariable(variable2, scope, this._activationRecordSlot); this.UpdateVariable(variable2, value); } } }
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) { // Use bytewise operation directly instead of 'var.IsReadOnly || var.IsConstant' on // a hot path (setting variable with type constraint) to get better performance. if ((var.Options & (ScopedItemOptions.ReadOnly | ScopedItemOptions.Constant)) != ScopedItemOptions.None) { SessionStateUnauthorizedAccessException e = new SessionStateUnauthorizedAccessException( var.Name, SessionStateCategory.Variable, "VariableNotWritable", SessionStateStrings.VariableNotWritable); throw e; } 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); // Don't update the PSVariable's attributes until we successfully set the value var.Attributes.Clear(); 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); }
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); }