internal void SetValue(PSObject obj, object property, object value, ExecutionContext context)
{
if (!LanguagePrimitives.IsNull((object)obj))
{
if (!LanguagePrimitives.IsNull(property))
{
try
{
if (PSObject.Base((object)obj) is IDictionary dictionary)
{
dictionary[property] = value;
return;
}
PSMemberInfo memberInfo = this.GetMemberInfo(obj, property, context);
if (memberInfo == null)
{
throw InterpreterError.NewInterpreterException(property, typeof(RuntimeException), this.NodeToken, "PropertyNotFound", property);
}
memberInfo.Value = value;
return;
}
catch (TerminateException ex)
{
throw;
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
throw InterpreterError.NewInterpreterExceptionByMessage(typeof(RuntimeException), this.NodeToken, ex.Message, "PropertyAssignmentException", ex);
}
}
}
throw InterpreterError.NewInterpreterException(property, typeof(RuntimeException), this.NodeToken, "PropertyNotFound", property);
}
internal void ReportEngineStartupError(string resourceString, params object[] arguments)
{
try
{
Cmdlet cmdlet;
string str;
if (this.IsModuleCommandCurrentlyRunning(out cmdlet, out str))
{
RuntimeException replaceParentContainsErrorRecordException = InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, str, resourceString, arguments);
cmdlet.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
}
else
{
PSHost engineHostInterface = this.EngineHostInterface;
if (engineHostInterface != null)
{
PSHostUserInterface uI = engineHostInterface.UI;
if (uI != null)
{
uI.WriteErrorLine(StringUtil.Format(resourceString, arguments));
}
}
}
}
catch (Exception exception2)
{
CommandProcessorBase.CheckForSevereException(exception2);
}
}
public FlagsExpression(object[] expression)
{
if (!typeof(T).IsEnum)
{
throw InterpreterError.NewInterpreterException(expression, typeof(RuntimeException), null, "InvalidGenericType", EnumExpressionEvaluatorStrings.InvalidGenericType, new object[0]);
}
this._underType = Enum.GetUnderlyingType(typeof(T));
if (expression == null)
{
throw InterpreterError.NewInterpreterException(null, typeof(ArgumentNullException), null, "EmptyInputString", EnumExpressionEvaluatorStrings.EmptyInputString, new object[0]);
}
foreach (string str in expression)
{
if (string.IsNullOrWhiteSpace(str))
{
throw InterpreterError.NewInterpreterException(expression, typeof(RuntimeException), null, "EmptyInputString", EnumExpressionEvaluatorStrings.EmptyInputString, new object[0]);
}
}
List <Token> tokenList = new List <Token>();
foreach (string str2 in expression)
{
tokenList.AddRange(this.TokenizeInput(str2));
tokenList.Add(new Token(TokenKind.Or));
}
this.CheckSyntaxError(tokenList);
this._root = this.ConstructExpressionTree(tokenList);
}
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 object SplitWithPattern(System.Management.Automation.ExecutionContext context, IScriptExtent errorPosition, IEnumerable <string> content, string separatorPattern, int limit, SplitOptions options)
{
if (((options & SplitOptions.SimpleMatch) == 0) && ((options & SplitOptions.RegexMatch) == 0))
{
options |= SplitOptions.RegexMatch;
}
if (((options & SplitOptions.SimpleMatch) != 0) && ((options & ~(SplitOptions.IgnoreCase | SplitOptions.SimpleMatch)) != 0))
{
throw InterpreterError.NewInterpreterException(null, typeof(ParseException), errorPosition, "InvalidSplitOptionCombination", ParserStrings.InvalidSplitOptionCombination, new object[0]);
}
if ((options & (SplitOptions.Singleline | SplitOptions.Multiline)) == (SplitOptions.Singleline | SplitOptions.Multiline))
{
throw InterpreterError.NewInterpreterException(null, typeof(ParseException), errorPosition, "InvalidSplitOptionCombination", ParserStrings.InvalidSplitOptionCombination, new object[0]);
}
if ((options & SplitOptions.SimpleMatch) != 0)
{
separatorPattern = Regex.Escape(separatorPattern);
}
if (limit < 0)
{
limit = 0;
}
RegexOptions options2 = parseRegexOptions(options);
Regex regex = NewRegex(separatorPattern, options2);
List <string> list = new List <string>();
foreach (string str in content)
{
string[] items = regex.Split(str, limit, 0);
ExtendList <string>(list, items);
}
return(list.ToArray());
}
internal static object StringToNumber(string input)
{
if (string.IsNullOrEmpty(input))
{
return((object)null);
}
input = input.Trim();
if (string.IsNullOrEmpty(input))
{
return((object)null);
}
string str1 = "";
if (input[0] == '+' || SpecialCharacters.IsDash(input[0]))
{
str1 = input[0].ToString();
input = input.Substring(1);
}
string str2 = NumberTokenReader.ScanForNumber(input, 0);
if (str2 == null)
{
return((object)null);
}
if (str2.Length < input.Length)
{
throw InterpreterError.NewInterpreterException((object)input, typeof(RuntimeException), (Token)null, "BadNumericConstant", (object)input);
}
return(NumberTokenReader.ConvertToNumber(str1 + str2, (Tokenizer)null));
}
internal object GetValue(object target, object index, ExecutionContext context)
{
if (LanguagePrimitives.IsNull(target))
{
throw InterpreterError.NewInterpreterException(index, typeof(RuntimeException), this.NodeToken, "NullArray");
}
if (LanguagePrimitives.IsNull(index))
{
throw InterpreterError.NewInterpreterException(index, typeof(RuntimeException), this.NodeToken, "NullArrayIndex");
}
switch (target)
{
case Array array:
return(this.DoGetValue(array, index, context));
case IDictionary dictionary:
return(this.DoGetValue(dictionary, index, context));
case string str:
return(this.DoGetValue(str, index, context));
default:
return(this.GetItemPropertyValue(target, index, context));
}
}
private static object GetUsingValue(MutableTuple tuple, int index, ExecutionContext context)
{
UsingResult usingValueFromTuple = GetUsingValueFromTuple(tuple, index);
if (usingValueFromTuple != null)
{
return(usingValueFromTuple.Value);
}
for (SessionStateScope scope = context.EngineSessionState.CurrentScope; scope != null; scope = scope.Parent)
{
usingValueFromTuple = GetUsingValueFromTuple(scope.LocalsTuple, index);
if (usingValueFromTuple != null)
{
return(usingValueFromTuple.Value);
}
foreach (MutableTuple tuple2 in scope.DottedScopes)
{
usingValueFromTuple = GetUsingValueFromTuple(tuple2, index);
if (usingValueFromTuple != null)
{
return(usingValueFromTuple.Value);
}
}
}
throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "UsingWithoutInvokeCommand", ParserStrings.UsingWithoutInvokeCommand, new object[0]);
}
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));
}
internal static Type ResolveTypeName(ITypeName typeName)
{
Type reflectionType = typeName.GetReflectionType();
if (reflectionType != null)
{
return(reflectionType);
}
GenericTypeName name = typeName as GenericTypeName;
if (name != null)
{
Type genericType = name.GetGenericType(ResolveTypeName(name.TypeName));
Type[] typeArguments = (from arg in name.GenericArguments select ResolveTypeName(arg)).ToArray <Type>();
try
{
if ((genericType != null) && genericType.ContainsGenericParameters)
{
genericType.MakeGenericType(typeArguments);
}
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
throw InterpreterError.NewInterpreterException(typeName, typeof(RuntimeException), null, "TypeNotFoundWithMessage", ParserStrings.TypeNotFoundWithMessage, new object[] { typeName.FullName, exception.Message });
}
}
ArrayTypeName name2 = typeName as ArrayTypeName;
if (name2 != null)
{
ResolveTypeName(name2.ElementType);
}
throw InterpreterError.NewInterpreterException(typeName, typeof(RuntimeException), null, "TypeNotFound", ParserStrings.TypeNotFound, new object[] { typeName.FullName });
}
internal static object AsOperator(object left, Type type)
{
bool flag;
if (type == null)
{
throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "AsOperatorRequiresType", ParserStrings.AsOperatorRequiresType, new object[0]);
}
LanguagePrimitives.ConversionData data = LanguagePrimitives.FigureConversion(left, type, out flag);
if (data.Rank == ConversionRank.None)
{
return(null);
}
try
{
if (flag)
{
return(data.Invoke(PSObject.Base(left), type, false, (PSObject)left, NumberFormatInfo.InvariantInfo, null));
}
return(data.Invoke(left, type, false, null, NumberFormatInfo.InvariantInfo, null));
}
catch (PSInvalidCastException)
{
return(null);
}
}
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 object GetNonIndexable(object target, object[] indices)
{
// We want to allow:
// $x[0]
// and
// $x[-1]
// to be the same as
// $x
// But disallow anything else:
// if in the strict mode, throw exception
// otherwise, return AutomationNull.Value to signal no result
if (indices.Length == 1)
{
var index = indices[0];
if (index != null && (LanguagePrimitives.Equals(0, index) || LanguagePrimitives.Equals(-1, index)))
{
return(target);
}
}
var context = LocalPipeline.GetExecutionContextFromTLS();
if (context == null || !context.IsStrictVersion(2))
{
return(AutomationNull.Value);
}
throw InterpreterError.NewInterpreterException(target, typeof(RuntimeException), null, "CannotIndex",
ParserStrings.CannotIndex, target.GetType());
}
private Attribute GetCustomAttribute()
{
Attribute customAttributeObject = this.GetCustomAttributeObject();
if (customAttributeObject != null && this._namedArguments != null)
{
Hashtable constValue = (Hashtable)this._namedArguments.GetConstValue();
PSObject psObject = LanguagePrimitives.AsPSObjectOrNull((object)customAttributeObject);
foreach (object key in (IEnumerable)constValue.Keys)
{
object obj = constValue[key];
try
{
PSMemberInfo member = psObject.Members[key.ToString()];
if (member != null)
{
member.Value = obj;
}
else
{
throw InterpreterError.NewInterpreterException((object)this.NodeToken, typeof(RuntimeException), this.NodeToken, "PropertyNotFoundForType", (object)key.ToString(), (object)customAttributeObject.GetType().ToString());
}
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
throw InterpreterError.NewInterpreterExceptionByMessage(typeof(RuntimeException), this.NodeToken, ex.Message, "PropertyAssignmentException", ex);
}
}
}
return(customAttributeObject);
}
private object BuildHashtable(
ParseTreeNode.ParseTreeNodeExecutor parseTreeNodeExecutor)
{
Hashtable hashtable = new Hashtable((IEqualityComparer)StringComparer.CurrentCultureIgnoreCase);
for (int index = 0; index < this._keys.Count; ++index)
{
object obj1 = this._keys[index];
if (obj1 is ParseTreeNode)
{
obj1 = parseTreeNodeExecutor((ParseTreeNode)obj1);
}
object obj2 = PSObject.Base(obj1);
if (obj2 == null || obj2 == AutomationNull.Value)
{
throw InterpreterError.NewInterpreterException(obj2, typeof(RuntimeException), this._tokens[index], "NullArrayIndex");
}
if (hashtable.ContainsKey(obj2))
{
string str = PSObject.ToStringParser((ExecutionContext)null, obj2);
if (str.Length > 40)
{
str = str.Substring(0, 40) + "...";
}
throw InterpreterError.NewInterpreterException(obj2, typeof(RuntimeException), this._tokens[index], "DuplicateKeyInHashLiteral", (object)str);
}
hashtable[obj2] = parseTreeNodeExecutor(this._expressions[index]);
}
return((object)hashtable);
}
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 void SetValue(object target, object index, object value)
{
if (LanguagePrimitives.IsNull(target))
{
throw InterpreterError.NewInterpreterException(index, typeof(RuntimeException), this.NodeToken, "NullArray");
}
if (LanguagePrimitives.IsNull(index))
{
throw InterpreterError.NewInterpreterException(target, typeof(RuntimeException), this.NodeToken, "NullArrayIndex");
}
switch (target)
{
case Array array:
this.DoSetValue(array, index, value);
break;
case IDictionary dictionary:
this.DoSetValue(dictionary, index, value);
break;
default:
this.SetItemPropertyValue(target, index, value);
break;
}
}
private void DoSetValue(Array array, object index, object value)
{
if (index is IList list)
{
if (array.Rank != 1)
{
if (list.Count > 1)
{
if (!(list[0] is IList))
{
goto label_5;
}
}
else
{
goto label_5;
}
}
throw InterpreterError.NewInterpreterException(index, typeof(RuntimeException), this.NodeToken, "ArraySliceAssignmentFailed", (object)ArrayReferenceNode.IndexStringMessage(index));
}
label_5:
try
{
this.SetArrayElement(array, index, value);
}
catch (IndexOutOfRangeException ex)
{
throw InterpreterError.NewInterpreterExceptionWithInnerException(index, typeof(RuntimeException), this.NodeToken, "IndexOutOfRange", (Exception)ex, (object)ArrayReferenceNode.IndexStringMessage(index));
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
throw InterpreterError.NewInterpreterExceptionWithInnerException(value, typeof(RuntimeException), this.NodeToken, "ArrayAssignmentFailed", ex, (object)ArrayReferenceNode.IndexStringMessage(index), (object)ex.Message);
}
}
/// <summary>
/// Construct the expression from a single string.
/// </summary>
/// <param name="expression">
/// The specified flag attribute expression string.
/// </param>
public FlagsExpression(string expression)
{
if (!typeof(T).IsEnum)
{
throw InterpreterError.NewInterpreterException(expression, typeof(RuntimeException),
null, "InvalidGenericType", EnumExpressionEvaluatorStrings.InvalidGenericType);
}
_underType = Enum.GetUnderlyingType(typeof(T));
if (String.IsNullOrWhiteSpace(expression))
{
throw InterpreterError.NewInterpreterException(expression, typeof(RuntimeException),
null, "EmptyInputString", EnumExpressionEvaluatorStrings.EmptyInputString);
}
List <Token> tokenList = TokenizeInput(expression);
// Append an OR at the end of the list for construction
tokenList.Add(new Token(TokenKind.Or));
CheckSyntaxError(tokenList);
Root = ConstructExpressionTree(tokenList);
}
/// <summary>
/// Efficiently multiplies collection by integer.
/// </summary>
/// <param name="array">Collection to multiply.</param>
/// <param name="times">Number of times the collection is to be multiplied/copied.</param>
/// <returns>Collection multiplied by integer.</returns>
internal static T[] Multiply <T>(T[] array, uint times)
{
Diagnostics.Assert(array != null, "Caller should verify the arguments for array multiplication");
if (times == 1)
{
return(array);
}
if (times == 0 || array.Length == 0)
{
#pragma warning disable CA1825 // Avoid zero-length array allocations
// Don't use Array.Empty<T>(); always return a new instance.
return(new T[0]);
#pragma warning restore CA1825 // Avoid zero-length array allocations
}
var context = LocalPipeline.GetExecutionContextFromTLS();
if (context != null &&
context.LanguageMode == PSLanguageMode.RestrictedLanguage && (array.Length * times) > 1024)
{
throw InterpreterError.NewInterpreterException(times, typeof(RuntimeException),
null, "ArrayMultiplyToolongInDataSection", ParserStrings.ArrayMultiplyToolongInDataSection, 1024);
}
var uncheckedLength = array.Length * times;
int elements = -1;
try
{
elements = checked ((int)uncheckedLength);
}
catch (OverflowException)
{
LanguagePrimitives.ThrowInvalidCastException(uncheckedLength, typeof(int));
}
// Make the minimum number of calls to Array.Copy by doubling the array up to
// the most significant bit in times, then do one final Array.Copy to get the
// remaining copies.
T[] result = new T[elements];
int resultLength = array.Length;
Array.Copy(array, 0, result, 0, resultLength);
times >>= 1;
while (times != 0)
{
Array.Copy(result, 0, result, resultLength, resultLength);
resultLength *= 2;
times >>= 1;
}
if (result.Length != resultLength)
{
Array.Copy(result, 0, result, resultLength, (result.Length - resultLength));
}
return(result);
}
private Token GetNextToken(string input, ref int _offset)
{
string str;
StringBuilder builder = new StringBuilder();
for (bool flag = false; _offset < input.Length; flag = true)
{
char ch = input[_offset++];
switch (ch)
{
case ',':
case '+':
case '!':
if (!flag)
{
builder.Append(ch);
}
else
{
_offset--;
}
goto Label_0054;
}
builder.Append(ch);
}
Label_0054:
str = builder.ToString().Trim();
if ((str.Length >= 2) && (((str[0] == '\'') && (str[str.Length - 1] == '\'')) || ((str[0] == '"') && (str[str.Length - 1] == '"'))))
{
str = str.Substring(1, str.Length - 2);
}
str = str.Trim();
if (string.IsNullOrWhiteSpace(str))
{
throw InterpreterError.NewInterpreterException(input, typeof(RuntimeException), null, "EmptyTokenString", EnumExpressionEvaluatorStrings.EmptyTokenString, new object[] { EnumMinimumDisambiguation.EnumAllValues(typeof(T)) });
}
if (str[0] == '(')
{
int index = input.IndexOf(')', _offset);
if ((str[str.Length - 1] == ')') || (index >= 0))
{
throw InterpreterError.NewInterpreterException(input, typeof(RuntimeException), null, "NoIdentifierGroupingAllowed", EnumExpressionEvaluatorStrings.NoIdentifierGroupingAllowed, new object[0]);
}
}
if (str.Equals(","))
{
return(new Token(TokenKind.Or));
}
if (str.Equals("+"))
{
return(new Token(TokenKind.And));
}
if (str.Equals("!"))
{
return(new Token(TokenKind.Not));
}
return(new Token(str));
}
/// <summary>
/// Get using values as dictionary for the Foreach-Object parallel cmdlet.
/// Ignore any using expressions that are associated with inner nested Foreach-Object parallel calls,
/// since they are only effective in the nested call scope and not the current outer scope.
/// </summary>
/// <param name = "scriptBlock">Scriptblock to search.</param>
/// <param name = "isTrustedInput">True when input is trusted.</param>
/// <param name = "context">Execution context.</param>
/// <param name = "foreachNames">List of foreach command names and aliases.</param>
/// <returns>Dictionary of using variable map.</returns>
internal static Dictionary <string, object> GetUsingValuesForEachParallel(
ScriptBlock scriptBlock,
bool isTrustedInput,
ExecutionContext context,
string[] foreachNames)
{
// Using variables for Foreach-Object -Parallel use are restricted to be within the
// Foreach-Object -Parallel call scope. This will filter the using variable map to variables
// only within the current (outer) Foreach-Object -Parallel call scope.
var usingAsts = UsingExpressionAstSearcher.FindAllUsingExpressions(scriptBlock.Ast).ToList();
UsingExpressionAst usingAst = null;
var usingValueMap = new Dictionary <string, object>(usingAsts.Count);
Version oldStrictVersion = null;
try
{
if (context != null)
{
oldStrictVersion = context.EngineSessionState.CurrentScope.StrictModeVersion;
context.EngineSessionState.CurrentScope.StrictModeVersion = PSVersionInfo.PSVersion;
}
for (int i = 0; i < usingAsts.Count; ++i)
{
usingAst = (UsingExpressionAst)usingAsts[i];
if (IsInForeachParallelCallingScope(usingAst, foreachNames))
{
var value = Compiler.GetExpressionValue(usingAst.SubExpression, isTrustedInput, context);
string usingAstKey = PsUtils.GetUsingExpressionKey(usingAst);
usingValueMap.TryAdd(usingAstKey, value);
}
}
}
catch (RuntimeException rte)
{
if (rte.ErrorRecord.FullyQualifiedErrorId.Equals("VariableIsUndefined", StringComparison.Ordinal))
{
throw InterpreterError.NewInterpreterException(
targetObject: null,
exceptionType: typeof(RuntimeException),
errorPosition: usingAst.Extent,
resourceIdAndErrorId: "UsingVariableIsUndefined",
resourceString: AutomationExceptions.UsingVariableIsUndefined,
args: rte.ErrorRecord.TargetObject);
}
}
finally
{
if (context != null)
{
context.EngineSessionState.CurrentScope.StrictModeVersion = oldStrictVersion;
}
}
return(usingValueMap);
}
private static void ReportIndexingError(Array array, object index, Exception reason)
{
string str = IndexStringMessage(index);
if (reason == null)
{
throw InterpreterError.NewInterpreterException(index, typeof(RuntimeException), null, "NeedMultidimensionalIndex", ParserStrings.NeedMultidimensionalIndex, new object[] { array.Rank, str });
}
throw InterpreterError.NewInterpreterExceptionWithInnerException(index, typeof(RuntimeException), null, "NeedMultidimensionalIndex", ParserStrings.NeedMultidimensionalIndex, reason, new object[] { array.Rank, str });
}
internal void ReportIndexingError(Array array, object index, Exception reason)
{
string str = ArrayReferenceNode.IndexStringMessage(index);
if (reason == null)
{
throw InterpreterError.NewInterpreterException(index, typeof(RuntimeException), this.NodeToken, "NeedMultidimensionalIndex", (object)array.Rank, (object)str);
}
throw InterpreterError.NewInterpreterExceptionWithInnerException(index, typeof(RuntimeException), this.NodeToken, "NeedMultidimensionalIndex", reason, (object)array.Rank, (object)str);
}
private string GetLabel(object result, ExecutionContext context)
{
string stringParser = PSObject.ToStringParser(context, result);
for (int index = 0; index < stringParser.Length; ++index)
{
if (!char.IsLetterOrDigit(stringParser[index]) && stringParser[index] != '_')
{
throw InterpreterError.NewInterpreterException((object)stringParser, typeof(RuntimeException), this.NodeToken, "InvalidLabelCharacter", (object)stringParser[index]);
}
}
return(stringParser);
}
internal override void Visit(CommandNode node)
{
if (this._allowedCommands != null && node.Expression == null && node.Elements[0] is Token element)
{
foreach (string allowedCommand in this._allowedCommands)
{
if (allowedCommand.Equals(element.TokenText, StringComparison.OrdinalIgnoreCase))
{
return;
}
}
throw InterpreterError.NewInterpreterException((object)element, typeof(RuntimeException), element, "CmdletNotInAllowedListForDataSection", (object)element.TokenText);
}
}
private static void ReportIndexingError(Array array, object index, Exception reason)
{
// Convert this index into something printable (we hope)...
string msgString = IndexStringMessage(index);
if (reason == null)
{
throw InterpreterError.NewInterpreterException(index, typeof(RuntimeException), null,
"NeedMultidimensionalIndex", ParserStrings.NeedMultidimensionalIndex, array.Rank, msgString);
}
throw InterpreterError.NewInterpreterExceptionWithInnerException(index, typeof(RuntimeException), null,
"NeedMultidimensionalIndex", ParserStrings.NeedMultidimensionalIndex, reason, array.Rank, msgString);
}
internal void CheckTypeConversionViolation()
{
if (this._typeConstraint == null || this._typeConstraint.Count <= 1)
{
return;
}
for (int index = 0; index < this._typeConstraint.Count - 1; ++index)
{
if (this._typeConstraint[index].IsRef)
{
throw InterpreterError.NewInterpreterException((object)this.NodeToken, typeof(RuntimeException), this.NodeToken, "ReferenceNeedsToBeLastTypeInTypeConversion");
}
}
}
private static object SplitOperatorImpl(System.Management.Automation.ExecutionContext context, IScriptExtent errorPosition, object lval, object rval, SplitImplOptions implOptions, bool ignoreCase)
{
IEnumerable <string> content = enumerateContent(context, errorPosition, implOptions, lval);
ScriptBlock predicate = null;
string separatorPattern = null;
int limit = 0;
SplitOptions options = 0;
object[] objArray = unfoldTuple(context, errorPosition, rval);
if (objArray.Length < 1)
{
throw InterpreterError.NewInterpreterException(rval, typeof(RuntimeException), errorPosition, "BadOperatorArgument", ParserStrings.BadOperatorArgument, new object[] { "-split", rval });
}
object obj1 = objArray[0];
predicate = objArray[0] as ScriptBlock;
if (predicate == null)
{
separatorPattern = PSObject.ToStringParser(context, objArray[0]);
}
if (objArray.Length >= 2)
{
limit = FixNum(objArray[1], errorPosition);
}
if ((objArray.Length >= 3) && (objArray[2] != null))
{
string str2 = objArray[2] as string;
if ((str2 == null) || !string.IsNullOrEmpty(str2))
{
options = ConvertTo <SplitOptions>(objArray[2], errorPosition);
if (predicate != null)
{
throw InterpreterError.NewInterpreterException(null, typeof(ParseException), errorPosition, "InvalidSplitOptionWithPredicate", ParserStrings.InvalidSplitOptionWithPredicate, new object[0]);
}
if (ignoreCase && ((options & SplitOptions.IgnoreCase) == 0))
{
options |= SplitOptions.IgnoreCase;
}
}
}
else if (ignoreCase)
{
options |= SplitOptions.IgnoreCase;
}
if (predicate != null)
{
return(SplitWithPredicate(context, errorPosition, content, predicate, limit));
}
return(SplitWithPattern(context, errorPosition, content, separatorPattern, limit, options));
}
internal static string EnumDisambiguate(string text, Type enumType)
{
string[] strArray2;
string[] enumNames = enumType.GetEnumNames();
CompareInfo.GetCompareInfo(CultureInfo.InvariantCulture.LCID);
List <string> list = new List <string>();
foreach (string str in enumNames)
{
if (str.StartsWith(text, StringComparison.OrdinalIgnoreCase))
{
list.Add(str);
}
}
if (list.Count == 0)
{
throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "NoEnumNameMatch", EnumExpressionEvaluatorStrings.NoEnumNameMatch, new object[] { text, EnumAllValues(enumType) });
}
if (list.Count == 1)
{
return(list[0]);
}
foreach (string str2 in list)
{
if (str2.Equals(text, StringComparison.OrdinalIgnoreCase))
{
return(str2);
}
}
if (specialDisambiguateCases.TryGetValue(enumType, out strArray2))
{
foreach (string str3 in strArray2)
{
if (str3.StartsWith(text, StringComparison.OrdinalIgnoreCase))
{
return(str3);
}
}
}
StringBuilder builder = new StringBuilder(list[0]);
string str4 = ", ";
for (int i = 1; i < list.Count; i++)
{
builder.Append(str4);
builder.Append(list[i]);
}
throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "MultipleEnumNameMatch", EnumExpressionEvaluatorStrings.MultipleEnumNameMatch, new object[] { text, builder.ToString() });
}