internal static string Multiply(string s, int times) { if (times < 0) { throw new ArgumentOutOfRangeException("times"); } if ((times == 0) || (s.Length == 0)) { return(string.Empty); } ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS(); if (((executionContextFromTLS != null) && (executionContextFromTLS.LanguageMode == PSLanguageMode.RestrictedLanguage)) && ((s.Length * times) > 0x400)) { throw InterpreterError.NewInterpreterException(times, typeof(RuntimeException), null, "StringMultiplyToolongInDataSection", ParserStrings.StringMultiplyToolongInDataSection, new object[] { 0x400 }); } if (s.Length == 1) { return(new string(s[0], times)); } return(new string(ArrayOps.Multiply <char>(s.ToCharArray(), (int)times))); }
private object GetItemPropertyValue(object obj, object index, ExecutionContext context) { IEnumerator enumerator = LanguagePrimitives.GetEnumerator(index); if (enumerator != null) { ArrayList arrayList = new ArrayList(); while (ParserOps.MoveNext(context, this.NodeToken, enumerator)) { try { object obj1 = this.GetItem(obj, enumerator.Current); arrayList.Add(obj1); } catch (Exception ex) { CommandProcessorBase.CheckForSevereException(ex); if (this.IsMethodNotFoundException(ex)) { throw InterpreterError.NewInterpreterExceptionWithInnerException(index, typeof(RuntimeException), this.NodeToken, "CannotIndex", ex, (object)obj.GetType().FullName); } } } return((object)arrayList.ToArray()); } try { return(this.GetItem(obj, index)); } catch (Exception ex) { CommandProcessorBase.CheckForSevereException(ex); if (this.IsMethodNotFoundException(ex)) { throw InterpreterError.NewInterpreterExceptionWithInnerException(index, typeof(RuntimeException), this.NodeToken, "CannotIndex", ex, (object)obj.GetType().FullName); } return((object)null); } }
internal static object PropertyGetter(PSGetMemberBinder binder, IEnumerator enumerator) { CallSite <Func <CallSite, object, object> > getMemberBinderSite = CallSite <Func <CallSite, object, object> > .Create(binder); ArrayList result = new ArrayList(); ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS(); PropertyGetterWorker(getMemberBinderSite, enumerator, executionContextFromTLS, result); if (result.Count == 1) { return(result[0]); } if (result.Count != 0) { return(result.ToArray()); } if (executionContextFromTLS.IsStrictVersion(2)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "PropertyNotFoundStrict", ParserStrings.PropertyNotFoundStrict, new object[] { binder.Name }); } return(null); }
internal static object MethodInvoker(PSInvokeMemberBinder binder, Type delegateType, IEnumerator enumerator, object[] args, Type typeForMessage) { CallSite invokeMemberSite = CallSite.Create(delegateType, binder); ArrayList result = new ArrayList(); ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS(); bool foundMethod = false; MethodInvokerWorker(invokeMemberSite, enumerator, args, executionContextFromTLS, result, ref foundMethod); if (result.Count == 1) { return(result[0]); } if (!foundMethod) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "MethodNotFound", ParserStrings.MethodNotFound, new object[] { typeForMessage.FullName, binder.Name }); } if (result.Count == 0) { return(AutomationNull.Value); } return(result.ToArray()); }
internal Pipe GetRedirectionPipe(ExecutionContext context, System.Management.Automation.Internal.PipelineProcessor parentPipelineProcessor) { if (string.IsNullOrWhiteSpace(this.File)) { return(new Pipe { NullPipe = true }); } CommandProcessorBase commandProcessor = context.CreateCommand("out-file", false); CommandParameterInternal parameter = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, "Encoding", "-Encoding:", PositionUtilities.EmptyExtent, "Unicode", false); commandProcessor.AddParameter(parameter); if (this.Appending) { parameter = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, "Append", "-Append:", PositionUtilities.EmptyExtent, true, false); commandProcessor.AddParameter(parameter); } parameter = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, "Filepath", "-Filepath:", PositionUtilities.EmptyExtent, this.File, false); commandProcessor.AddParameter(parameter); this.PipelineProcessor = new System.Management.Automation.Internal.PipelineProcessor(); this.PipelineProcessor.Add(commandProcessor); try { this.PipelineProcessor.StartStepping(true); } catch (RuntimeException exception) { if (exception.ErrorRecord.Exception is ArgumentException) { throw InterpreterError.NewInterpreterExceptionWithInnerException(null, typeof(RuntimeException), null, "RedirectionFailed", ParserStrings.RedirectionFailed, exception.ErrorRecord.Exception, new object[] { this.File, exception.ErrorRecord.Exception.Message }); } throw; } if (parentPipelineProcessor != null) { parentPipelineProcessor.AddRedirectionPipe(this.PipelineProcessor); } return(new Pipe(context, this.PipelineProcessor)); }
internal ScriptCommandProcessor( string script, ExecutionContext context, bool isFilter, bool useLocalScope, bool interactiveCommand, CommandOrigin origin) { this.Context = context; this._interactiveCommand = interactiveCommand; this._dontUseScopeCommandOrigin = false; this._rethrowExitException = this.Context.ScriptCommandProcessorShouldRethrowExit; this.Context.ScriptCommandProcessorShouldRethrowExit = false; if (origin == CommandOrigin.Runspace && this.Context.LanguageMode == PSLanguageMode.NoLanguage) { throw InterpreterError.NewInterpreterException((object)script, typeof(ParseException), (Token)null, "ScriptsNotAllowed"); } this._scriptBlock = this.Context.Engine.ParseScriptBlock(script, interactiveCommand); if (origin == CommandOrigin.Runspace) { switch (this.Context.LanguageMode) { case PSLanguageMode.FullLanguage: break; case PSLanguageMode.RestrictedLanguage: RestrictedLanguageModeChecker.Check(this.Context.Engine.EngineParser, this._scriptBlock, (IEnumerable <string>)null, false); break; default: throw new InvalidOperationException("Invalid langage mode was set when building a ScriptCommandProcessor"); } } this.CommandInfo = (CommandInfo) new ScriptInfo(string.Empty, this._scriptBlock, context); this._fromPipeline = true; this.SetupCommand(); this.Command.CommandOriginInternal = origin; this.UseLocalScope = useLocalScope; }
internal override object Execute(Array input, Pipe outputPipe, ExecutionContext context) { this.CheckForInterrupts(context); object obj1 = (object)null; try { obj1 = this._rightHandSide.Execute(input, (Pipe)null, context); if (obj1 == AutomationNull.Value) { obj1 = (object)null; } IAssignableValue assignableValue = this._left.GetAssignableValue(input, context); object obj2 = this._operationDelegate == null ? obj1 : this._operationDelegate(context, this.NodeToken, assignableValue.GetValue(context), obj1); assignableValue.SetValue(obj2, context); return(obj2); } catch (ScriptCallDepthException ex) { throw; } catch (FlowControlException ex) { throw; } catch (RuntimeException ex) { if (ex.ErrorRecord != null && ex.ErrorRecord.InvocationInfo == null) { ex.ErrorRecord.SetInvocationInfo(new InvocationInfo((CommandInfo)null, this.NodeToken, context)); } throw; } catch (Exception ex) { CommandProcessorBase.CheckForSevereException(ex); throw InterpreterError.NewInterpreterException(obj1, typeof(RuntimeException), this.NodeToken, "OperatorFailed", (object)this.NodeToken.TokenText, (object)ex.Message); } }
internal static object GetAutomaticVariableValue(int tupleIndex, ExecutionContext executionContext, VariableExpressionAst varAst) { Diagnostics.Assert(tupleIndex < SpecialVariables.AutomaticVariableTypes.Length, "caller to verify a valid tuple index is used"); if (executionContext._debuggingMode > 0) { executionContext.Debugger.CheckVariableRead(SpecialVariables.AutomaticVariables[tupleIndex]); } object result = executionContext.EngineSessionState.GetAutomaticVariableValue((AutomaticVariable)tupleIndex); if (result == AutomationNull.Value) { if (ThrowStrictModeUndefinedVariable(executionContext, varAst)) { throw InterpreterError.NewInterpreterException(SpecialVariables.AutomaticVariables[tupleIndex], typeof(RuntimeException), varAst.Extent, "VariableIsUndefined", ParserStrings.VariableIsUndefined, SpecialVariables.AutomaticVariables[tupleIndex]); } result = null; } return(result); }
internal static string Multiply(string s, int times) { Diagnostics.Assert(s != null, "caller to verify argument is not null"); if (times < 0) { // TODO: this should be a runtime error. throw new ArgumentOutOfRangeException("times"); } if (times == 0 || s.Length == 0) { return(String.Empty); } var context = LocalPipeline.GetExecutionContextFromTLS(); if (context != null && context.LanguageMode == PSLanguageMode.RestrictedLanguage && (s.Length * times) > 1024) { throw InterpreterError.NewInterpreterException(times, typeof(RuntimeException), null, "StringMultiplyToolongInDataSection", ParserStrings.StringMultiplyToolongInDataSection, 1024); } if (s.Length == 1) { // A string of length 1 has special support in the BCL, so just use it. return(new string(s[0], times)); } // Convert the string to a char array, use the array multiplication code, // then construct a new string from the resulting char array. This uses // extra memory compared to the naive algorithm, but is faster (measured // against a V2 CLR, should be measured against V4 as the StringBuilder // implementation changed.) return(new string(ArrayOps.Multiply(s.ToCharArray(), (uint)times))); }
internal static object IsOperator(System.Management.Automation.ExecutionContext context, IScriptExtent errorPosition, object left, object right) { object o = PSObject.Base(left); object obj3 = PSObject.Base(right); Type type = obj3 as Type; if (type == null) { type = ConvertTo <Type>(obj3, errorPosition); if (type == null) { throw InterpreterError.NewInterpreterException(obj3, typeof(RuntimeException), errorPosition, "IsOperatorRequiresType", ParserStrings.IsOperatorRequiresType, new object[0]); } } if ((type == typeof(PSCustomObject)) && (o is PSObject)) { return(_TrueObject); } if (type.Equals(typeof(PSObject)) && (left is PSObject)) { return(_TrueObject); } return(BoolToObject(type.IsInstanceOfType(o))); }
internal static object GetUsingValue(MutableTuple tuple, string usingExpressionKey, int index, ExecutionContext context) { UsingResult result = GetUsingValueFromTuple(tuple, usingExpressionKey, index); if (result != null) { return(result.Value); } var scope = context.EngineSessionState.CurrentScope; while (scope != null) { result = GetUsingValueFromTuple(scope.LocalsTuple, usingExpressionKey, index); if (result != null) { return(result.Value); } foreach (var dottedScope in scope.DottedScopes) { result = GetUsingValueFromTuple(dottedScope, usingExpressionKey, index); if (result != null) { return(result.Value); } } scope = scope.Parent; } // $PSBoundParameters is null or not the expected type (because someone may have assigned to it), so // we can't even guess if they were mis-using $using:foo throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "UsingWithoutInvokeCommand", ParserStrings.UsingWithoutInvokeCommand); }
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 RuntimeException NewInterpreterExceptionWithInnerException( object targetObject, Type exceptionType, Token errToken, string resourceIdAndErrorId, Exception innerException, params object[] args) { if (string.IsNullOrEmpty(resourceIdAndErrorId)) { throw InterpreterError.tracer.NewArgumentException(nameof(resourceIdAndErrorId)); } RuntimeException runtimeException; try { string message = args == null || args.Length == 0 ? ResourceManagerCache.GetResourceString("Parser", resourceIdAndErrorId) : ResourceManagerCache.FormatResourceString("Parser", resourceIdAndErrorId, args); runtimeException = !string.IsNullOrEmpty(message) ? InterpreterError.NewInterpreterExceptionByMessage(exceptionType, errToken, message, resourceIdAndErrorId, innerException) : InterpreterError.NewBackupInterpreterException(exceptionType, errToken, resourceIdAndErrorId, (Exception)null); } catch (InvalidOperationException ex) { runtimeException = InterpreterError.NewBackupInterpreterException(exceptionType, errToken, resourceIdAndErrorId, (Exception)ex); } catch (MissingManifestResourceException ex) { runtimeException = InterpreterError.NewBackupInterpreterException(exceptionType, errToken, resourceIdAndErrorId, (Exception)ex); } catch (FormatException ex) { runtimeException = InterpreterError.NewBackupInterpreterException(exceptionType, errToken, resourceIdAndErrorId, (Exception)ex); } runtimeException.SetTargetObject(targetObject); return(runtimeException); }
private void ExecuteFileSwitch( Array input, Pipe outputPipe, ref ArrayList resultList, ExecutionContext context) { string filePath = this.GetFilePath(context); try { using (StreamReader streamReader = new StreamReader(filePath)) { string str; while ((str = streamReader.ReadLine()) != null) { try { this.ProcessClauses((object)str, outputPipe, ref resultList, context); } catch (BreakException ex) { if (this.MatchLabel(ex.Label)) { break; } throw; } catch (ContinueException ex) { if (!this.MatchLabel(ex.Label)) { throw; } } } } } catch (BreakException ex) { throw; } catch (ContinueException ex) { throw; } catch (ReturnException ex) { throw; } catch (ExitException ex) { throw; } catch (TerminateException ex) { throw; } catch (Exception ex) { CommandProcessorBase.CheckForSevereException(ex); throw InterpreterError.NewInterpreterExceptionWithInnerException((object)filePath, typeof(RuntimeException), this._expression.NodeToken, "FileReadError", ex, (object)ex.Message); } }
/// <summary> /// Perform disambiguation on enum names /// </summary> /// <returns>complete enum name after disambiguation</returns> internal static string EnumDisambiguate(string text, Type enumType) { // Get all enum names in the given enum type string[] enumNames = Enum.GetNames(enumType); // Get all names that matches the given prefix. List <string> namesWithMatchingPrefix = new List <string>(); foreach (string name in enumNames) { if (name.StartsWith(text, StringComparison.OrdinalIgnoreCase)) { namesWithMatchingPrefix.Add(name); } } // Throw error when no match is found. if (namesWithMatchingPrefix.Count == 0) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "NoEnumNameMatch", EnumExpressionEvaluatorStrings.NoEnumNameMatch, text, EnumAllValues(enumType)); } // Return the result if there is only one match. else if (namesWithMatchingPrefix.Count == 1) { return(namesWithMatchingPrefix[0]); } // multiple matches situation else { // test for exact match foreach (string matchName in namesWithMatchingPrefix) { if (matchName.Equals(text, StringComparison.OrdinalIgnoreCase)) { return(matchName); } } // test for special cases match string[] minDisambiguateNames; if (s_specialDisambiguateCases.TryGetValue(enumType, out minDisambiguateNames)) { foreach (string tName in minDisambiguateNames) { if (tName.StartsWith(text, StringComparison.OrdinalIgnoreCase)) { return(tName); } } } // No special cases match, throw error for multiple matches. StringBuilder matchListSB = new StringBuilder(namesWithMatchingPrefix[0]); string separator = ", "; for (int i = 1; i < namesWithMatchingPrefix.Count; i++) { matchListSB.Append(separator); matchListSB.Append(namesWithMatchingPrefix[i]); } throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "MultipleEnumNameMatch", EnumExpressionEvaluatorStrings.MultipleEnumNameMatch, text, matchListSB.ToString()); } }
private CommandProcessorBase CreateCommandProcessor( out int index, ExecutionContext context) { index = 0; CommandProcessorBase commandProcessorBase = (CommandProcessorBase)null; if (this._expression != null) { return((CommandProcessorBase) new ScriptCommandProcessor(ScriptBlock.CreateSynthesized(this._expression, this.NodeToken), context, false)); } bool createScope; SessionStateInternal commandSessionState; bool forceSessionState; object commandName = this.GetCommandName(out createScope, out index, out commandSessionState, out forceSessionState, context); switch (commandName) { case ScriptBlock scriptblock: commandProcessorBase = CommandDiscovery.CreateCommandProcessorForScript(scriptblock, context, createScope); if (commandProcessorBase.CommandSessionState == null || forceSessionState) { commandProcessorBase.CommandSessionState = commandSessionState; break; } break; case CommandInfo commandInfo: commandProcessorBase = context.CommandDiscovery.LookupCommandProcessor(commandInfo, context.EngineSessionState.currentScope.ScopeOrigin, new bool?(false)); break; case string stringParser: label_7: if (string.IsNullOrEmpty(stringParser)) { throw InterpreterError.NewInterpreterException(commandName, typeof(RuntimeException), (Token)this._elements[0], "BadExpression", (object)((Token)this._elements[0]).TokenText); } try { if (commandSessionState != context.EngineSessionState) { SessionStateInternal engineSessionState = context.EngineSessionState; try { context.EngineSessionState = commandSessionState; commandProcessorBase = context.CreateCommand(stringParser); break; } finally { context.EngineSessionState = engineSessionState; } } else { commandProcessorBase = context.CreateCommand(stringParser); break; } } catch (ParseException ex) { throw; } catch (RuntimeException ex) { if (ex.ErrorRecord.InvocationInfo == null) { ex.ErrorRecord.SetInvocationInfo(new InvocationInfo((CommandInfo)null, (Token)this._elements[0], context)); } throw; } default: stringParser = PSObject.ToStringParser(context, commandName); goto label_7; } if (commandProcessorBase.CommandSessionState == null || forceSessionState) { commandProcessorBase.CommandSessionState = commandSessionState; } InternalCommand command = commandProcessorBase.Command; command.MyInvocation.ScriptToken = (Token)this._elements[0]; if (context.IsStrictVersion(2) && this._elements.Count == index + 1 && (this._elements[index - 1] is Token && this._elements[index] is ArrayLiteralNode)) { Token element = (Token)this._elements[index - 1]; if (element.Script[element.End] == '(') { throw InterpreterError.NewInterpreterException((object)null, typeof(RuntimeException), (Token)this._elements[index - 1], "StrictModeFunctionCallWithParens"); } } if (createScope) { switch (command) { case ScriptCommand _: case PSScriptCmdlet _: commandProcessorBase.UseLocalScope = true; commandProcessorBase.CommandScope = commandProcessorBase.CommandSessionState == null?context.EngineSessionState.NewScope(commandProcessorBase.FromScriptFile) : commandProcessorBase.CommandSessionState.NewScope(commandProcessorBase.FromScriptFile); goto label_27; } } commandProcessorBase.UseLocalScope = false; commandProcessorBase.CommandScope = commandProcessorBase.CommandSessionState.CurrentScope; label_27: commandProcessorBase.Command.CallingToken = (Token)this._elements[0]; return(commandProcessorBase); }
private object GetCommandName( out bool createScope, out int index, out SessionStateInternal commandSessionState, out bool forceSessionState, ExecutionContext context) { createScope = true; index = 0; forceSessionState = false; commandSessionState = context.EngineSessionState; if (this._elements.Count == 0) { return((object)null); } Token element = (Token)this._elements[index++]; if (element.Is(TokenId.DotToken)) { createScope = false; } else if (!element.Is(TokenId.AmpersandToken)) { return((object)element.TokenText); } for (int index1 = 0; index1 < 2; ++index1) { ParseTreeNode parseTreeNode = (ParseTreeNode)null; if (index < this._elements.Count) { parseTreeNode = this._elements[index++] as ParseTreeNode; } object obj = parseTreeNode != null?PSObject.Base(parseTreeNode.Execute(context)) : throw InterpreterError.NewInterpreterException((object)null, typeof(RuntimeException), element, "MissingExpression", (object)element.TokenText); if (!(obj is PSModuleInfo psModuleInfo)) { return(obj); } if (psModuleInfo.ModuleType == ModuleType.Binary && psModuleInfo.SessionState == null) { throw InterpreterError.NewInterpreterException((object)null, typeof(RuntimeException), element, "CantInvokeInBinaryModule", (object)psModuleInfo.Name); } commandSessionState = psModuleInfo.SessionState.Internal; forceSessionState = true; } return((object)null); }
internal static object MatchOperator(System.Management.Automation.ExecutionContext context, IScriptExtent errorPosition, object lval, object rval, bool notMatch, bool ignoreCase) { object obj3; RegexOptions options = ignoreCase ? RegexOptions.IgnoreCase : RegexOptions.None; Regex regex = PSObject.Base(rval) as Regex; if (regex == null) { regex = NewRegex(PSObject.ToStringParser(context, rval), options); } IEnumerator targetObject = LanguagePrimitives.GetEnumerator(lval); if (targetObject == null) { string input = (lval == null) ? string.Empty : PSObject.ToStringParser(context, lval); Match match = regex.Match(input); if (match.Success) { GroupCollection groups = match.Groups; if (groups.Count > 0) { Hashtable newValue = new Hashtable(StringComparer.CurrentCultureIgnoreCase); foreach (string str2 in regex.GetGroupNames()) { Group group = groups[str2]; if (group.Success) { int num; if (int.TryParse(str2, out num)) { newValue.Add(num, group.ToString()); } else { newValue.Add(str2, group.ToString()); } } } context.SetVariable(SpecialVariables.MatchesVarPath, newValue); } } return(BoolToObject(match.Success ^ notMatch)); } ArrayList list = new ArrayList(); int num2 = 0; try { while (targetObject.MoveNext()) { object current = targetObject.Current; string str3 = (current == null) ? string.Empty : PSObject.ToStringParser(context, current); if (regex.Match(str3).Success ^ notMatch) { list.Add(current); } if (num2++ > 0x3e8) { if ((context != null) && context.CurrentPipelineStopping) { throw new PipelineStoppedException(); } num2 = 0; } } obj3 = list.ToArray(); } catch (RuntimeException) { throw; } catch (FlowControlException) { throw; } catch (ScriptCallDepthException) { throw; } catch (Exception exception) { CommandProcessorBase.CheckForSevereException(exception); throw InterpreterError.NewInterpreterExceptionWithInnerException(targetObject, typeof(RuntimeException), errorPosition, "BadEnumeration", ParserStrings.BadEnumeration, exception, new object[] { exception.Message }); } return(obj3); }
internal static object CallMethod(IScriptExtent errorPosition, object target, string methodName, PSMethodInvocationConstraints invocationConstraints, object[] paramArray, bool callStatic, object valueToSet) { PSMethodInfo staticCLRMember = null; MethodInformation methodInformation = null; object obj2 = null; PSObject obj3 = null; Type type; object obj4; if (LanguagePrimitives.IsNull(target)) { throw InterpreterError.NewInterpreterException(methodName, typeof(RuntimeException), errorPosition, "InvokeMethodOnNull", ParserStrings.InvokeMethodOnNull, new object[0]); } obj2 = PSObject.Base(target); obj3 = PSObject.AsPSObject(target); CallsiteCacheEntryFlags none = CallsiteCacheEntryFlags.None; if (callStatic) { none |= CallsiteCacheEntryFlags.Static; type = (Type)obj2; } else { type = obj2.GetType(); } if (valueToSet != AutomationNull.Value) { none |= CallsiteCacheEntryFlags.ParameterizedSetter; } if (!obj3.isDeserialized) { methodInformation = Adapter.FindCachedMethod(type, methodName, invocationConstraints, paramArray, none); } if (methodInformation == null) { if (callStatic) { staticCLRMember = PSObject.GetStaticCLRMember(target, methodName) as PSMethod; } else { staticCLRMember = obj3.Members[methodName] as PSMethodInfo; } if (staticCLRMember == null) { string fullName = null; if (callStatic) { fullName = type.FullName; } else { fullName = GetTypeFullName(target); } if (valueToSet == AutomationNull.Value) { throw InterpreterError.NewInterpreterException(methodName, typeof(RuntimeException), errorPosition, "MethodNotFound", ParserStrings.MethodNotFound, new object[] { fullName, methodName }); } throw InterpreterError.NewInterpreterException(methodName, typeof(RuntimeException), errorPosition, "ParameterizedPropertyAssignmentFailed", ParserStrings.ParameterizedPropertyAssignmentFailed, new object[] { fullName, methodName }); } } try { if (methodInformation != null) { object[] objArray; PSObject.memberResolution.WriteLine("cache hit, Calling Method: {0}", new object[] { methodInformation.methodDefinition }); if (valueToSet != AutomationNull.Value) { DotNetAdapter.ParameterizedPropertyInvokeSet(methodName, obj2, valueToSet, new MethodInformation[] { methodInformation }, paramArray, false); return(valueToSet); } MethodInformation[] methods = new MethodInformation[] { methodInformation }; Adapter.GetBestMethodAndArguments(methodName, methods, paramArray, out objArray); return(DotNetAdapter.AuxiliaryMethodInvoke(obj2, objArray, methodInformation, paramArray)); } if (valueToSet != AutomationNull.Value) { PSParameterizedProperty property = staticCLRMember as PSParameterizedProperty; if (property == null) { throw InterpreterError.NewInterpreterException(methodName, typeof(RuntimeException), errorPosition, "ParameterizedPropertyAssignmentFailed", ParserStrings.ParameterizedPropertyAssignmentFailed, new object[] { GetTypeFullName(target), methodName }); } property.InvokeSet(valueToSet, paramArray); return(valueToSet); } PSMethod method = staticCLRMember as PSMethod; if (method != null) { return(method.Invoke(invocationConstraints, paramArray)); } obj4 = staticCLRMember.Invoke(paramArray); } catch (MethodInvocationException exception) { if (exception.ErrorRecord.InvocationInfo == null) { exception.ErrorRecord.SetInvocationInfo(new InvocationInfo(null, errorPosition)); } throw; } catch (RuntimeException exception2) { if (exception2.ErrorRecord.InvocationInfo == null) { exception2.ErrorRecord.SetInvocationInfo(new InvocationInfo(null, errorPosition)); } throw; } catch (FlowControlException) { throw; } catch (ScriptCallDepthException) { throw; } catch (Exception exception3) { CommandProcessorBase.CheckForSevereException(exception3); throw InterpreterError.NewInterpreterExceptionByMessage(typeof(RuntimeException), errorPosition, exception3.Message, "MethodInvocationException", exception3); } return(obj4); }
internal void InitializeRuntimeDefinedParameters(ref bool useCmdletBinding) { if (this._runtimeDefinedParameters != null) { return; } this._runtimeDefinedParameters = new RuntimeDefinedParameterDictionary(); this._runtimeDefinedParameterList = new List <RuntimeDefinedParameter>(); bool flag = false; if (!useCmdletBinding) { for (int index = 0; index < this._parameters.Count; ++index) { if (this._parameters[index].HasParameterAttribute()) { useCmdletBinding = true; break; } } } int num1 = 0; for (int index = 0; index < this._parameters.Count; ++index) { RuntimeDefinedParameter definedParameter = this._parameters[index].GetRuntimeDefinedParameter(useCmdletBinding); if (!useCmdletBinding) { ParameterAttribute parameterAttribute = new ParameterAttribute(); if (!this._parameters[index].IsSwitchParameter()) { parameterAttribute.Position = num1++; } definedParameter.Attributes.Add((Attribute)parameterAttribute); } else { foreach (Attribute attribute in definedParameter.Attributes) { if (attribute is ParameterAttribute parameterAttribute && (parameterAttribute.Position != int.MinValue || !parameterAttribute.ParameterSetName.Equals("__AllParameterSets", StringComparison.OrdinalIgnoreCase))) { flag = true; break; } } } try { this._runtimeDefinedParameters.Add(definedParameter.Name, definedParameter); this._runtimeDefinedParameterList.Add(definedParameter); } catch (ArgumentException ex) { throw InterpreterError.NewInterpreterException((object)null, typeof(RuntimeException), this._parameters[index].NodeToken, "DuplicateFormalParameter", (object)this._parameters[index].NodeToken.TokenText); } } if (!useCmdletBinding || flag) { return; } for (int index = 0; index < this._runtimeDefinedParameterList.Count; ++index) { foreach (Attribute attribute in this._runtimeDefinedParameterList[index].Attributes) { if (attribute is ParameterAttribute parameterAttribute && !this._parameters[index].IsSwitchParameter()) { int num2 = num1++; parameterAttribute.Position = num2; break; } } } }
private static CommandProcessorBase AddCommand(PipelineProcessor pipe, CommandParameterInternal[] commandElements, CommandBaseAst commandBaseAst, CommandRedirection[] redirections, System.Management.Automation.ExecutionContext context) { object parameterText; IScriptExtent parameterExtent; CommandProcessorBase base2; InternalCommand command; string str3; HelpCategory category; CommandAst ast = commandBaseAst as CommandAst; TokenKind kind = (ast != null) ? ast.InvocationOperator : TokenKind.Unknown; bool dotSource = kind == TokenKind.Dot; SessionStateInternal sessionState = null; int index = 0; PSModuleInfo info = PSObject.Base(commandElements[0].ArgumentValue) as PSModuleInfo; if (info != null) { if ((info.ModuleType == ModuleType.Binary) && (info.SessionState == null)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "CantInvokeInBinaryModule", ParserStrings.CantInvokeInBinaryModule, new object[] { info.Name }); } if (info.SessionState == null) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "CantInvokeInNonImportedModule", ParserStrings.CantInvokeInNonImportedModule, new object[] { info.Name }); } sessionState = info.SessionState.Internal; index++; } CommandParameterInternal internal3 = commandElements[index]; if (internal3.ParameterNameSpecified) { parameterText = internal3.ParameterText; parameterExtent = internal3.ParameterExtent; if (!internal3.ArgumentSpecified) { } } else { parameterText = PSObject.Base(internal3.ArgumentValue); parameterExtent = internal3.ArgumentExtent; } string str = dotSource ? "." : ((kind == TokenKind.Ampersand) ? "&" : null); ScriptBlock scriptblock = parameterText as ScriptBlock; if (scriptblock != null) { base2 = CommandDiscovery.CreateCommandProcessorForScript(scriptblock, context, !dotSource, sessionState); } else { CommandInfo commandInfo = parameterText as CommandInfo; if (commandInfo != null) { base2 = context.CommandDiscovery.LookupCommandProcessor(commandInfo, context.EngineSessionState.CurrentScope.ScopeOrigin, new bool?(!dotSource), sessionState); } else { string str2 = (parameterText as string) ?? PSObject.ToStringParser(context, parameterText); str = str ?? str2; if (string.IsNullOrEmpty(str2)) { throw InterpreterError.NewInterpreterException(parameterText, typeof(RuntimeException), parameterExtent, "BadExpression", ParserStrings.BadExpression, new object[] { dotSource ? "." : "&" }); } try { if (sessionState != null) { SessionStateInternal engineSessionState = context.EngineSessionState; try { context.EngineSessionState = sessionState; base2 = context.CreateCommand(str2, dotSource); goto Label_025D; } finally { context.EngineSessionState = engineSessionState; } } base2 = context.CreateCommand(str2, dotSource); } catch (RuntimeException exception) { if (exception.ErrorRecord.InvocationInfo == null) { InvocationInfo invocationInfo = new InvocationInfo(null, parameterExtent, context) { InvocationName = str }; exception.ErrorRecord.SetInvocationInfo(invocationInfo); } throw; } } } Label_025D: command = base2.Command; base2.UseLocalScope = !dotSource && ((command is ScriptCommand) || (command is PSScriptCmdlet)); bool flag2 = base2 is NativeCommandProcessor; for (int i = index + 1; i < commandElements.Length; i++) { CommandParameterInternal parameter = commandElements[i]; if ((!parameter.ParameterNameSpecified || !parameter.ParameterName.Equals("-", StringComparison.OrdinalIgnoreCase)) || flag2) { if (parameter.ArgumentSplatted) { foreach (CommandParameterInternal internal6 in Splat(parameter.ArgumentValue, parameter.ArgumentExtent)) { base2.AddParameter(internal6); } } else { base2.AddParameter(parameter); } } } if (base2.IsHelpRequested(out str3, out category)) { base2 = CommandProcessorBase.CreateGetHelpCommandProcessor(context, str3, category); } base2.Command.InvocationExtent = commandBaseAst.Extent; base2.Command.MyInvocation.ScriptPosition = commandBaseAst.Extent; base2.Command.MyInvocation.InvocationName = str; pipe.Add(base2); bool flag3 = false; bool flag4 = false; bool flag5 = false; bool flag6 = false; if (redirections != null) { foreach (CommandRedirection redirection in redirections) { redirection.Bind(pipe, base2, context); switch (redirection.FromStream) { case RedirectionStream.All: flag3 = true; flag4 = true; flag5 = true; flag6 = true; break; case RedirectionStream.Error: flag3 = true; break; case RedirectionStream.Warning: flag4 = true; break; case RedirectionStream.Verbose: flag5 = true; break; case RedirectionStream.Debug: flag6 = true; break; } } } if (!flag3) { if (context.ShellFunctionErrorOutputPipe != null) { base2.CommandRuntime.ErrorOutputPipe = context.ShellFunctionErrorOutputPipe; } else { base2.CommandRuntime.ErrorOutputPipe.ExternalWriter = context.ExternalErrorOutput; } } if (!flag4 && (context.ExpressionWarningOutputPipe != null)) { base2.CommandRuntime.WarningOutputPipe = context.ExpressionWarningOutputPipe; flag4 = true; } if (!flag5 && (context.ExpressionVerboseOutputPipe != null)) { base2.CommandRuntime.VerboseOutputPipe = context.ExpressionVerboseOutputPipe; flag5 = true; } if (!flag6 && (context.ExpressionDebugOutputPipe != null)) { base2.CommandRuntime.DebugOutputPipe = context.ExpressionDebugOutputPipe; flag6 = true; } if ((context.CurrentCommandProcessor != null) && (context.CurrentCommandProcessor.CommandRuntime != null)) { if (!flag4 && (context.CurrentCommandProcessor.CommandRuntime.WarningOutputPipe != null)) { base2.CommandRuntime.WarningOutputPipe = context.CurrentCommandProcessor.CommandRuntime.WarningOutputPipe; } if (!flag5 && (context.CurrentCommandProcessor.CommandRuntime.VerboseOutputPipe != null)) { base2.CommandRuntime.VerboseOutputPipe = context.CurrentCommandProcessor.CommandRuntime.VerboseOutputPipe; } if (!flag6 && (context.CurrentCommandProcessor.CommandRuntime.DebugOutputPipe != null)) { base2.CommandRuntime.DebugOutputPipe = context.CurrentCommandProcessor.CommandRuntime.DebugOutputPipe; } } return(base2); }
internal static object ReplaceOperator(System.Management.Automation.ExecutionContext context, IScriptExtent errorPosition, object lval, object rval, bool ignoreCase) { string replacement = ""; object obj2 = ""; rval = PSObject.Base(rval); IList list = rval as IList; if (list != null) { if (list.Count > 2) { throw InterpreterError.NewInterpreterException(rval, typeof(RuntimeException), errorPosition, "BadReplaceArgument", ParserStrings.BadReplaceArgument, new object[] { ignoreCase ? "-ireplace" : "-replace", list.Count }); } if (list.Count > 0) { obj2 = list[0]; if (list.Count > 1) { replacement = PSObject.ToStringParser(context, list[1]); } } } else { obj2 = rval; } RegexOptions none = RegexOptions.None; if (ignoreCase) { none = RegexOptions.IgnoreCase; } Regex regex = obj2 as Regex; if (regex == null) { try { regex = NewRegex(PSObject.ToStringParser(context, obj2), none); } catch (ArgumentException exception) { throw InterpreterError.NewInterpreterExceptionWithInnerException(obj2, typeof(RuntimeException), null, "InvalidRegularExpression", ParserStrings.InvalidRegularExpression, exception, new object[] { obj2 }); } } IEnumerator enumerator = LanguagePrimitives.GetEnumerator(lval); if (enumerator == null) { string input = ((lval == null) ? string.Empty : lval).ToString(); return(regex.Replace(input, replacement)); } ArrayList list2 = new ArrayList(); while (MoveNext(context, errorPosition, enumerator)) { string str3 = PSObject.ToStringParser(context, Current(errorPosition, enumerator)); list2.Add(regex.Replace(str3, replacement)); } return(list2.ToArray()); }
/// <summary> /// Collect values for UsingExpressions, in the form of a dictionary and an array. /// - The dictionary form is used when the remote server is PSv5 and later version for handling UsingExpression in Invoke-Command/Start-Job /// - The array form is used when the remote server is PSv3 and PSv4 for handling UsingExpression in Invoke-Command. /// </summary> /// <remarks> /// We still keep the array-form using values because we want to avoid any breaking changes when running Invoke-Command /// targeting PSv3 or PSv4 remote end -- if UsingExpressions are all in the same scope, then we still pass an array of using /// values to the remote end; otherwise, we will handle UsingExpression as if the remote end is PSv2. /// </remarks> /// <returns> /// A tuple of the dictionary-form and the array-form using values. /// If the array-form using value is null, then there are UsingExpressions used in different scopes. /// </returns> private static Tuple <Dictionary <string, object>, object[]> GetUsingValues(Ast body, bool isTrustedInput, ExecutionContext context, Dictionary <string, object> variables, bool filterNonUsingVariables) { Diagnostics.Assert(context != null || variables != null, "can't retrieve variables with no context and no variables"); var usingAsts = UsingExpressionAstSearcher.FindAllUsingExpressionExceptForWorkflow(body).ToList(); var usingValueArray = new object[usingAsts.Count]; var usingValueMap = new Dictionary <string, object>(usingAsts.Count); HashSet <string> usingVarNames = (variables != null && filterNonUsingVariables) ? new HashSet <string>() : null; // Used to check if the PSv3/PSv4 way of handling UsingExpression can continue to be used. bool hasUsingExprInDifferentScope = false; ScriptBlockAst sbClosestToPreUsingExpr = null; UsingExpressionAst usingAst = null; 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]; object value = null; // This happens only when GetUsingValues gets called outside the ScriptBlockToPowerShellConverter class if (!hasUsingExprInDifferentScope && HasUsingExpressionsInDifferentScopes(usingAst, body, ref sbClosestToPreUsingExpr)) { // If there are UsingExpressions in different scopes, the array-form using values will not be useful // even if the remote end is PSv3 or PSv4, because the way we handle using expression in PSv3 and PSv4 // doesn't support UsingExpression in different scopes. In this case, we will set the array-form using // value to be null before return. // // Note that this check only affect array-form using value. In PSv5, we change the way to handle UsingExpression // on both client and server sides. The dictionary-form using values is used and UsingExpression in different // scope is supported. hasUsingExprInDifferentScope = true; } if (variables != null) { var variableAst = usingAst.SubExpression as VariableExpressionAst; if (variableAst == null) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingAst.Extent, "CantGetUsingExpressionValueWithSpecifiedVariableDictionary", AutomationExceptions.CantGetUsingExpressionValueWithSpecifiedVariableDictionary, usingAst.Extent.Text); } string varName = variableAst.VariablePath.UserPath; if (varName != null && variables.TryGetValue(varName, out value) && usingVarNames != null) { usingVarNames.Add(varName); } } else { value = Compiler.GetExpressionValue(usingAst.SubExpression, isTrustedInput, context); } // Collect UsingExpression value as an array usingValueArray[i] = value; // Collect UsingExpression value as a dictionary string usingAstKey = PsUtils.GetUsingExpressionKey(usingAst); usingValueMap.TryAdd(usingAstKey, value); } } catch (RuntimeException rte) { if (rte.ErrorRecord.FullyQualifiedErrorId.Equals("VariableIsUndefined", StringComparison.Ordinal)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingAst.Extent, "UsingVariableIsUndefined", AutomationExceptions.UsingVariableIsUndefined, rte.ErrorRecord.TargetObject); } else if (rte.ErrorRecord.FullyQualifiedErrorId.Equals("CantGetUsingExpressionValueWithSpecifiedVariableDictionary", StringComparison.Ordinal)) { throw; } } finally { if (context != null) { context.EngineSessionState.CurrentScope.StrictModeVersion = oldStrictVersion; } } if (usingVarNames != null) { string[] keys = variables.Keys.ToArray(); foreach (string key in keys) { if (!usingVarNames.Contains(key)) { variables.Remove(key); } } } if (hasUsingExprInDifferentScope) { usingValueArray = null; } return(Tuple.Create(usingValueMap, usingValueArray)); }
private object PrivateGetValue(ExecutionContext context) { try { if (this._useConstantValue) { return(this._constantValue); } if (!this._variablePath.IsScopedItem) { CmdletProviderContext context1 = (CmdletProviderContext)null; SessionStateScope scope = (SessionStateScope)null; SessionStateInternal engineSessionState = context.EngineSessionState; return(engineSessionState.GetVariableValueFromProvider(this._variablePath, out context1, out scope, engineSessionState.currentScope.ScopeOrigin)); } PSVariable variable = this.GetVariable(context); if (this._typeConstraint != null && this._typeConstraint.Count == 1 && this._typeConstraint[0].Type.Equals(typeof(PSReference))) { return(variable != null ? (object)new PSReference((object)variable) : throw InterpreterError.NewInterpreterException((object)this.NodeToken, typeof(RuntimeException), this.NodeToken, "NonExistingVariableReference", (object)this.NodeToken)); } if (variable != null) { return(variable.Value); } if (context.Debugger.IsOn) { context.Debugger.CheckVariableRead(this._varName); } return((object)null); } catch (RuntimeException ex) { if (ex.ErrorRecord != null && ex.ErrorRecord.InvocationInfo == null) { ex.ErrorRecord.SetInvocationInfo(new InvocationInfo((CommandInfo)null, this.NodeToken, context)); } throw; } }
internal static void CheckActionPreference(FunctionContext funcContext, Exception exception) { ActionPreference preference; if (exception is TargetInvocationException) { exception = exception.InnerException; } CommandProcessorBase.CheckForSevereException(exception); RuntimeException exception2 = exception as RuntimeException; if (exception2 == null) { exception2 = ConvertToRuntimeException(exception, funcContext.CurrentPosition); } else { InterpreterError.UpdateExceptionErrorRecordPosition(exception2, funcContext.CurrentPosition); } RuntimeException.LockStackTrace(exception2); ExecutionContext context = funcContext._executionContext; Pipe outputPipe = funcContext._outputPipe; IScriptExtent scriptPosition = exception2.ErrorRecord.InvocationInfo.ScriptPosition; SetErrorVariables(scriptPosition, exception2, context, outputPipe); context.QuestionMarkVariableValue = false; bool flag = funcContext._traps.Any <Tuple <Type[], Action <FunctionContext>[], Type[]> >() && (funcContext._traps.Last <Tuple <Type[], Action <FunctionContext>[], Type[]> >().Item2 != null); if (!flag && !NeedToQueryForActionPreference(exception2, context)) { throw exception2; } if (flag) { preference = ProcessTraps(funcContext, exception2); } else { preference = QueryForAction(exception2, exception2.Message, context); } context.QuestionMarkVariableValue = false; switch (preference) { case ActionPreference.SilentlyContinue: case ActionPreference.Ignore: return; case ActionPreference.Stop: exception2.SuppressPromptInInterpreter = true; throw exception2; } if (!flag && exception2.WasThrownFromThrowStatement) { throw exception2; } bool flag2 = ReportErrorRecord(scriptPosition, exception2, context); context.QuestionMarkVariableValue = false; if (!flag2) { throw exception2; } }
private static object[] GetUsingValues(Ast body, ExecutionContext context, Dictionary <string, object> variables, bool filterNonUsingVariables) { List <Ast> list = UsingExpressionAstSearcher.FindAllUsingExpressionExceptForWorkflow(body).ToList <Ast>(); object[] objArray = new object[list.Count]; HashSet <string> set = ((variables != null) && filterNonUsingVariables) ? new HashSet <string>() : null; UsingExpressionAst usingExpr = null; Version strictModeVersion = null; try { if (context != null) { strictModeVersion = context.EngineSessionState.CurrentScope.StrictModeVersion; context.EngineSessionState.CurrentScope.StrictModeVersion = PSVersionInfo.PSVersion; } for (int i = 0; i < objArray.Length; i++) { usingExpr = (UsingExpressionAst)list[i]; if (IsUsingExpressionInFunction(usingExpr, body)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingExpr.Extent, "UsingVariableNotSupportedInFunctionOrFilter", AutomationExceptions.UsingVariableNotSupportedInFunctionOrFilter, new object[] { usingExpr }); } object obj2 = null; if (variables != null) { VariableExpressionAst subExpression = usingExpr.SubExpression as VariableExpressionAst; if (subExpression == null) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingExpr.Extent, "CantGetUsingExpressionValueWithSpecifiedVariableDictionary", AutomationExceptions.CantGetUsingExpressionValueWithSpecifiedVariableDictionary, new object[] { usingExpr.Extent.Text }); } string userPath = subExpression.VariablePath.UserPath; if (((userPath != null) && variables.TryGetValue(userPath, out obj2)) && (set != null)) { set.Add(userPath); } } else { obj2 = Compiler.GetExpressionValue(usingExpr.SubExpression, context, (IList)null); } objArray[i] = obj2; usingExpr.RuntimeUsingIndex = i; } } catch (RuntimeException exception) { if (exception.ErrorRecord.FullyQualifiedErrorId.Equals("VariableIsUndefined", StringComparison.Ordinal)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingExpr.Extent, "UsingVariableIsUndefined", AutomationExceptions.UsingVariableIsUndefined, new object[] { exception.ErrorRecord.TargetObject }); } if (exception.ErrorRecord.FullyQualifiedErrorId.Equals("UsingVariableNotSupportedInFunctionOrFilter", StringComparison.Ordinal) || exception.ErrorRecord.FullyQualifiedErrorId.Equals("CantGetUsingExpressionValueWithSpecifiedVariableDictionary", StringComparison.Ordinal)) { throw; } } finally { if (context != null) { context.EngineSessionState.CurrentScope.StrictModeVersion = strictModeVersion; } } if (set != null) { foreach (string str2 in variables.Keys.ToArray <string>()) { if (!set.Contains(str2)) { variables.Remove(str2); } } } return(objArray); }
internal static void ThrowError(ScriptBlockToPowerShellNotSupportedException ex, Ast ast) { InterpreterError.UpdateExceptionErrorRecordPosition(ex, ast.Extent); throw ex; }
private void ExecuteStatement( ParseTreeNode statement, Array input, Pipe outputPipe, ref ArrayList resultList, ExecutionContext context) { ScriptTrace.TraceLine(context, statement); Exception e = (Exception)null; try { try { if (statement.IsVoidable) { statement.Execute(input, (Pipe)null, context); } else { statement.Execute(input, outputPipe, ref resultList, context); } ParseTreeNode parseTreeNode = statement; while (parseTreeNode is AssignmentStatementNode assignmentStatementNode) { parseTreeNode = assignmentStatementNode.RightHandSide; } if (parseTreeNode.IsExpression) { context.QuestionMarkVariableValue = true; } else if (parseTreeNode is PipelineNode pipelineNode) { context.QuestionMarkVariableValue = !pipelineNode.ExecutionFailed(context); } } catch (COMException ex) { throw InterpreterError.NewInterpreterExceptionWithInnerException((object)null, typeof(RuntimeException), statement.NodeToken, "COMException", (Exception)ex, (object)ex.Message); } catch (InvalidComObjectException ex) { throw InterpreterError.NewInterpreterExceptionWithInnerException((object)null, typeof(RuntimeException), statement.NodeToken, "InvalidComObjectException", (Exception)ex, (object)ex.Message); } } catch (ReturnException ex) { if (resultList == null || resultList.Count == 0) { e = (Exception)ex; } else { ParseTreeNode.AppendResult(context, ex.Argument, (Pipe)null, ref resultList); ex.SetArgument((object)resultList.ToArray()); resultList = (ArrayList)null; e = (Exception)ex; } } catch (RuntimeException ex) { e = this.HandleException(statement.NodeToken, ex, outputPipe, ref resultList, context); } if (e != null) { RuntimeException.LockStackTrace(e); throw e; } }
/// <summary> /// Given the start (offset) of the next token, traverse through /// the string to find the next token, stripping correctly /// enclosed quotes. /// </summary> /// <param name="input"> /// Input string /// </param> /// <param name="_offset"> /// Current offset position for the string parser. /// </param> /// <returns> /// The next token on the input string /// </returns> private Token GetNextToken(string input, ref int _offset) { StringBuilder sb = new StringBuilder(); //bool singleQuoted = false; //bool doubleQuoted = false; bool readingIdentifier = false; while (_offset < input.Length) { char cc = input[_offset++]; if ((cc == ',') || (cc == '+') || (cc == '!')) { if (!readingIdentifier) { sb.Append(cc); } else { _offset--; } break; } else { sb.Append(cc); readingIdentifier = true; } } string result = sb.ToString().Trim(); // If resulting identifier is enclosed in paired quotes, // remove the only the first pair of quotes from the string if (result.Length >= 2 && ((result[0] == '\'' && result[result.Length - 1] == '\'') || (result[0] == '\"' && result[result.Length - 1] == '\"'))) { result = result.Substring(1, result.Length - 2); } result = result.Trim(); // possible empty token because white spaces are enclosed in quotation marks. if (String.IsNullOrWhiteSpace(result)) { throw InterpreterError.NewInterpreterException(input, typeof(RuntimeException), null, "EmptyTokenString", EnumExpressionEvaluatorStrings.EmptyTokenString, EnumMinimumDisambiguation.EnumAllValues(typeof(T))); } else if (result[0] == '(') { int matchIndex = input.IndexOf(')', _offset); if (result[result.Length - 1] == ')' || matchIndex >= 0) { throw InterpreterError.NewInterpreterException(input, typeof(RuntimeException), null, "NoIdentifierGroupingAllowed", EnumExpressionEvaluatorStrings.NoIdentifierGroupingAllowed); } } if (result.Equals(",")) { return(new Token(TokenKind.Or)); } else if (result.Equals("+")) { return(new Token(TokenKind.And)); } else if (result.Equals("!")) { return(new Token(TokenKind.Not)); } else { return(new Token(result)); } }
internal void Validate(Parser parser) { if (!this._validated && this._catchBlocks.Count > 1) { Exception exception = (Exception)null; try { for (int index1 = 0; index1 < this._catchBlocks.Count - 1; ++index1) { ExceptionHandlerNode catchBlock1 = this._catchBlocks[index1]; for (int index2 = index1 + 1; index2 < this._catchBlocks.Count; ++index2) { ExceptionHandlerNode catchBlock2 = this._catchBlocks[index2]; if (catchBlock1.ExceptionTypes == null) { if (parser != null) { parser.ReportException((object)null, typeof(ParseException), catchBlock1.NodeToken, "EmptyCatchNotLast"); break; } exception = (Exception)InterpreterError.NewInterpreterException((object)null, typeof(RuntimeException), catchBlock1.NodeToken, "EmptyCatchNotLast"); break; } if (catchBlock2.ExceptionTypes != null) { foreach (TypeLiteral exceptionType1 in (Collection <TypeLiteral>)catchBlock1.ExceptionTypes) { Type type1 = exceptionType1.Type; foreach (TypeLiteral exceptionType2 in (Collection <TypeLiteral>)catchBlock2.ExceptionTypes) { Type type2 = exceptionType2.Type; if (type1 == type2 || type2.IsSubclassOf(type1)) { if (parser != null) { parser.ReportException((object)null, typeof(ParseException), exceptionType2.Token, "ExceptionTypeAlreadyCaught", (object)type2); } else { exception = (Exception)InterpreterError.NewInterpreterException((object)null, typeof(RuntimeException), exceptionType2.Token, "ExceptionTypeAlreadyCaught", (object)type2); } } } } } } } } catch (ParseException ex) { throw; } catch (RuntimeException ex) { return; } if (exception != null) { throw exception; } } this._validated = true; }