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);
}