Beispiel #1
0
        internal void CaptureLocals()
        {
            if (this._sessionState == null)
            {
                throw PSTraceSource.NewInvalidOperationException("Modules", "InvalidOperationOnBinaryModule", new object[0]);
            }
            ExecutionContext         executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
            MutableTuple             localsTuple             = executionContextFromTLS.EngineSessionState.CurrentScope.LocalsTuple;
            IEnumerable <PSVariable> values = executionContextFromTLS.EngineSessionState.CurrentScope.Variables.Values;

            if (localsTuple != null)
            {
                Dictionary <string, PSVariable> result = new Dictionary <string, PSVariable>();
                localsTuple.GetVariableTable(result, false);
                values = result.Values.Concat <PSVariable>(values);
            }
            foreach (PSVariable variable in values)
            {
                try
                {
                    if (variable.Options == ScopedItemOptions.None)
                    {
                        PSVariable variable2 = new PSVariable(variable.Name, variable.Value, variable.Options, variable.Attributes, variable.Description);
                        this._sessionState.Internal.NewVariable(variable2, false);
                    }
                }
                catch (SessionStateException)
                {
                }
            }
        }
Beispiel #2
0
        internal static object InvokeAdaptedSetMember(object obj, string methodName, object[] args, object valueToSet)
        {
            TypeTable        typeTable;
            ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
            object           obj1 = obj;

            if (executionContextFromTLS != null)
            {
                typeTable = executionContextFromTLS.TypeTable;
            }
            else
            {
                typeTable = null;
            }
            PSObject.AdapterSet     mappedAdapter           = PSObject.GetMappedAdapter(obj1, typeTable);
            PSParameterizedProperty pSParameterizedProperty = mappedAdapter.OriginalAdapter.BaseGetMember <PSParameterizedProperty>(obj, methodName);

            if (pSParameterizedProperty == null && mappedAdapter.DotNetAdapter != null)
            {
                pSParameterizedProperty = mappedAdapter.DotNetAdapter.BaseGetMember <PSParameterizedProperty>(obj, methodName);
            }
            if (pSParameterizedProperty == null)
            {
                object[] typeFullName = new object[2];
                typeFullName[0] = ParserOps.GetTypeFullName(obj);
                typeFullName[1] = methodName;
                throw InterpreterError.NewInterpreterException(methodName, typeof(RuntimeException), null, "MethodNotFound", ParserStrings.MethodNotFound, typeFullName);
            }
            else
            {
                pSParameterizedProperty.InvokeSet(valueToSet, args);
                return(valueToSet);
            }
        }
Beispiel #3
0
        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());
        }
Beispiel #4
0
        public PSModuleInfo(ScriptBlock scriptBlock)
        {
            this._context = LocalPipeline.GetExecutionContextFromTLS();
            if (this._context == null)
            {
                throw new InvalidOperationException(nameof(PSModuleInfo));
            }
            PSModuleInfo.SetDefaultDynamicNameAndPath(this);
            this._sessionState = new SessionState(this._context.EngineSessionState, true, true);
            this._sessionState.Internal.Module = this;
            SessionStateInternal engineSessionState = this._context.EngineSessionState;

            try
            {
                ArrayList resultList = (ArrayList)null;
                this._context.EngineSessionState = this._sessionState.Internal;
                this._context.EngineSessionState.SetVariableValue("PSScriptRoot", (object)this._path);
                scriptBlock = scriptBlock.Clone(true);
                scriptBlock.SessionState = this._sessionState;
                if (scriptBlock == null)
                {
                    throw PSModuleInfo.tracer.NewInvalidOperationException();
                }
                scriptBlock.InvokeWithPipe(false, true, (object)AutomationNull.Value, (object)AutomationNull.Value, (object)AutomationNull.Value, (Pipe)null, ref resultList);
            }
            finally
            {
                this._context.EngineSessionState = engineSessionState;
            }
        }
Beispiel #5
0
        internal static object GetAdaptedValue(object obj, string member)
        {
            ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
            PSMemberInfo     memberInfo = null;

            if ((executionContextFromTLS != null) && (executionContextFromTLS.TypeTable != null))
            {
                ConsolidatedString typeNames = PSObject.GetTypeNames(obj);
                memberInfo = executionContextFromTLS.TypeTable.GetMembers <PSMemberInfo>(typeNames)[member];
                if (memberInfo != null)
                {
                    memberInfo = CloneMemberInfo(memberInfo, obj);
                }
            }
            PSObject.AdapterSet mappedAdapter = PSObject.GetMappedAdapter(obj, (executionContextFromTLS != null) ? executionContextFromTLS.TypeTable : null);
            if (memberInfo == null)
            {
                memberInfo = mappedAdapter.OriginalAdapter.BaseGetMember <PSMemberInfo>(obj, member);
            }
            if ((memberInfo == null) && (mappedAdapter.DotNetAdapter != null))
            {
                memberInfo = mappedAdapter.DotNetAdapter.BaseGetMember <PSMemberInfo>(obj, member);
            }
            if (memberInfo != null)
            {
                return(memberInfo.Value);
            }
            if ((executionContextFromTLS != null) && executionContextFromTLS.IsStrictVersion(2))
            {
                throw new PropertyNotFoundException("PropertyNotFoundStrict", null, ParserStrings.PropertyNotFoundStrict, new object[] { LanguagePrimitives.ConvertTo <string>(member) });
            }
            return(null);
        }
Beispiel #6
0
        internal static int FormatEnumerationLimit()
        {
            object enumLimitVal = null;

            try
            {
                // Win8: 192504
                if (LocalPipeline.GetExecutionContextFromTLS() != null)
                {
                    enumLimitVal = LocalPipeline.GetExecutionContextFromTLS()
                                   .SessionState.PSVariable
                                   .GetValue("global:" + InitialSessionState.FormatEnumerationLimit);
                }
            }
            // Eat the following exceptions, enumerationLimit will use the default value
            catch (ProviderNotFoundException)
            {
            }
            catch (ProviderInvocationException)
            {
            }

            // if $global:FormatEnumerationLimit is an int, overwrite the default value
            return(enumLimitVal is int?(int)enumLimitVal : InitialSessionState.DefaultFormatEnumerationLimit);
        }
Beispiel #7
0
        // Keep in sync:
        // S.M.A.CommandProcessorBase.CheckForSevereException
        // S.M.A.Internal.ConsoleHost.CheckForSevereException
        // S.M.A.Commands.CommandsCommon.CheckForSevereException
        // S.M.A.Commands.UtilityCommon.CheckForSevereException
        /// <summary>
        /// Checks whether the exception is a severe exception which should
        /// cause immediate process failure.
        /// </summary>
        /// <param name="cmdlet">can be null</param>
        /// <param name="e"></param>
        /// <remarks>
        /// CB says 02/23/2005: I personally would err on the side
        /// of treating OOM like an application exception, rather than
        /// a critical system failure.I think this will be easier to justify
        /// in Orcas, if we tease apart the two cases of OOM better.
        /// But even in Whidbey, how likely is it that we couldnt JIT
        /// some backout code?  At that point, the process or possibly
        /// the machine is likely to stop executing soon no matter
        /// what you do in this routine.  So I would just consider
        /// AccessViolationException.  (I understand why you have SO here,
        /// at least temporarily).
        /// </remarks>
        internal static void CheckForSevereException(PSCmdlet cmdlet, Exception e)
        {
            if (e is AccessViolationException || e is StackOverflowException)
            {
                try
                {
                    if (!alreadyFailing)
                    {
                        alreadyFailing = true;

                        // Get the ExecutionContext from the thread.
                        ExecutionContext context =
                            (null != cmdlet)
                                ? cmdlet.Context
                                : LocalPipeline.GetExecutionContextFromTLS();

                        // Log a command health event for this critical error.
                        MshLog.LogCommandHealthEvent(context, e, Severity.Critical);
                    }
                }
                finally
                {
                    if (!designForTestability_SkipFailFast)
                    {
                        WindowsErrorReporting.FailFast(e);
                    }
                }
            }
        }
Beispiel #8
0
        internal static object GetMDArrayValue(Array array, int[] indexes, bool slicing)
        {
            if (array.Rank != indexes.Length)
            {
                ReportIndexingError(array, indexes, null);
            }

            for (int i = 0; i < indexes.Length; ++i)
            {
                int ub = array.GetUpperBound(i);
                int lb = array.GetLowerBound(i);
                if (indexes[i] < lb)
                {
                    indexes[i] = indexes[i] + ub + 1;
                }

                if (indexes[i] < lb || indexes[i] > ub)
                {
                    // In strict mode, don't return, fall through and let Array.GetValue raise an exception.
                    var context = LocalPipeline.GetExecutionContextFromTLS();
                    if (context != null && !context.IsStrictVersion(3))
                    {
                        // If we're slicing, return AutomationNull.Value to signal no result)
                        return(slicing ? AutomationNull.Value : null);
                    }
                }
            }

            // All indexes have been validated, so this won't raise an exception.
            return(array.GetValue(indexes));
        }
Beispiel #9
0
 internal static object GetMDArrayValue(Array array, int[] indexes, bool slicing)
 {
     if (array.Rank != indexes.Length)
     {
         ReportIndexingError(array, indexes, null);
     }
     for (int i = 0; i < indexes.Length; i++)
     {
         int upperBound = array.GetUpperBound(i);
         int lowerBound = array.GetLowerBound(i);
         if (indexes[i] < lowerBound)
         {
             indexes[i] = (indexes[i] + upperBound) + 1;
         }
         if ((indexes[i] < lowerBound) || (indexes[i] > upperBound))
         {
             ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
             if ((executionContextFromTLS != null) && !executionContextFromTLS.IsStrictVersion(3))
             {
                 if (!slicing)
                 {
                     return(null);
                 }
                 return(AutomationNull.Value);
             }
         }
     }
     return(array.GetValue(indexes));
 }
Beispiel #10
0
        /// <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);
        }
Beispiel #11
0
        /// <summary>
        /// Constructs the MergedCommandParameterMetadata, using any arguments that
        /// may have been specified so that dynamic parameters can be determined, if any.
        /// </summary>
        /// <returns></returns>
        private MergedCommandParameterMetadata GetMergedCommandParameterMetadataSafely()
        {
            if (_context == null)
            {
                return(null);
            }

            MergedCommandParameterMetadata result;

            if (_context != LocalPipeline.GetExecutionContextFromTLS())
            {
                // In the normal case, _context is from the thread we're on, and we won't get here.
                // But, if it's not, we can't safely get the parameter metadata without running on
                // on the correct thread, because that thread may be busy doing something else.
                // One of the things we do here is change the current scope in execution context,
                // that can mess up the runspace our CommandInfo object came from.

                var runspace = (RunspaceBase)_context.CurrentRunspace;
                if (runspace.CanRunActionInCurrentPipeline())
                {
                    GetMergedCommandParameterMetadata(out result);
                }
                else
                {
                    _context.Events.SubscribeEvent(
                        source: null,
                        eventName: PSEngineEvent.GetCommandInfoParameterMetadata,
                        sourceIdentifier: PSEngineEvent.GetCommandInfoParameterMetadata,
                        data: null,
                        handlerDelegate: new PSEventReceivedEventHandler(OnGetMergedCommandParameterMetadataSafelyEventHandler),
                        supportEvent: true,
                        forwardEvent: false,
                        shouldQueueAndProcessInExecutionThread: true,
                        maxTriggerCount: 1);

                    var eventArgs = new GetMergedCommandParameterMetadataSafelyEventArgs();

                    _context.Events.GenerateEvent(
                        sourceIdentifier: PSEngineEvent.GetCommandInfoParameterMetadata,
                        sender: null,
                        args: new[] { eventArgs },
                        extraData: null,
                        processInCurrentThread: true,
                        waitForCompletionInCurrentThread: true);

                    if (eventArgs.Exception != null)
                    {
                        // An exception happened on a different thread, rethrow it here on the correct thread.
                        eventArgs.Exception.Throw();
                    }

                    return(eventArgs.Result);
                }
            }

            GetMergedCommandParameterMetadata(out result);
            return(result);
        }
Beispiel #12
0
        internal static void Trace(int level, string messageId, string resourceString, params object[] args)
        {
            ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();

            if (executionContextFromTLS != null)
            {
                Trace(executionContextFromTLS, level, messageId, resourceString, args);
            }
        }
Beispiel #13
0
        private static CommandCompletion CompleteInputImpl(Ast ast, Token[] tokens, IScriptPosition positionOfCursor, Hashtable options)
        {
            PowerShell powershell        = PowerShell.Create(RunspaceMode.CurrentRunspace);
            int        replacementIndex  = -1;
            int        replacementLength = -1;
            List <CompletionResult> list = null;

            if (NeedToInvokeLegacyTabExpansion(powershell))
            {
                Tuple <string, int, int> inputAndCursorFromAst = GetInputAndCursorFromAst(positionOfCursor);
                list              = InvokeLegacyTabExpansion(powershell, inputAndCursorFromAst.Item1, inputAndCursorFromAst.Item2, false, out replacementIndex, out replacementLength);
                replacementIndex += inputAndCursorFromAst.Item3;
            }
            if ((list == null) || (list.Count == 0))
            {
                ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
                MutableTuple     tuple2 = null;
                foreach (CallStackFrame frame in executionContextFromTLS.Debugger.GetCallStack())
                {
                    dynamic obj2  = PSObject.AsPSObject(frame);
                    var     site1 = CallSite <Func <CallSite, object, bool> > .Create(Binder.UnaryOperation(CSharpBinderFlags.None, ExpressionType.IsTrue, typeof(CommandCompletion), new CSharpArgumentInfo[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }));

                    if (site1.Target(site1, obj2.Command.Equals("TabExpansion2", StringComparison.OrdinalIgnoreCase)))
                    {
                        tuple2 = frame.FunctionContext._localsTuple;
                        break;
                    }
                }
                SessionStateScope currentScope = null;
                if (tuple2 != null)
                {
                    currentScope = executionContextFromTLS.EngineSessionState.CurrentScope;
                    SessionStateScope parent = executionContextFromTLS.EngineSessionState.CurrentScope;
                    while ((parent != null) && (parent.LocalsTuple != tuple2))
                    {
                        parent = parent.Parent;
                    }
                    if (parent != null)
                    {
                        executionContextFromTLS.EngineSessionState.CurrentScope = parent.Parent;
                    }
                }
                try
                {
                    list = new CompletionAnalysis(ast, tokens, positionOfCursor, options).GetResults(powershell, out replacementIndex, out replacementLength);
                }
                finally
                {
                    if (currentScope != null)
                    {
                        executionContextFromTLS.EngineSessionState.CurrentScope = currentScope;
                    }
                }
            }
            return(new CommandCompletion(new Collection <CompletionResult>(list ?? EmptyCompletionResult), -1, replacementIndex, replacementLength));
        }
Beispiel #14
0
        internal static TypeTable GetTypeTableFromTLS()
        {
            ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();

            if (executionContextFromTLS == null)
            {
                return(null);
            }
            return(executionContextFromTLS.TypeTable);
        }
Beispiel #15
0
        private static Assembly PowerShellAssemblyResolveHandler(object sender, ResolveEventArgs args)
        {
            ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();

            if (((executionContextFromTLS != null) && (executionContextFromTLS._assemblyCache != null)) && executionContextFromTLS._assemblyCache.ContainsKey(args.Name))
            {
                return(executionContextFromTLS._assemblyCache[args.Name]);
            }
            return(null);
        }
Beispiel #16
0
        internal static void Trace(int level, string messageId, params object[] args)
        {
            ExecutionContext executionContextFromTls = LocalPipeline.GetExecutionContextFromTLS();

            if (executionContextFromTls == null)
            {
                return;
            }
            ScriptTrace.Trace(executionContextFromTls, level, messageId, args);
        }
Beispiel #17
0
        public SessionState()
        {
            ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();

            if (executionContextFromTLS == null)
            {
                throw new InvalidOperationException("ExecutionContext");
            }
            this.sessionState = new SessionStateInternal(executionContextFromTLS);
            this.sessionState.PublicSessionState = this;
        }
Beispiel #18
0
        /// <summary>
        /// This method calls all Validate attributes for the property to validate value.
        /// Called from class property setters with ValidateArgumentsAttribute attributes.
        /// </summary>
        /// <param name="type"></param>
        /// <param name="propertyName"></param>
        /// <param name="value"></param>
        public static void ValidateSetProperty(Type type, string propertyName, object value)
        {
            var validateAttributes = type.GetProperty(propertyName).GetCustomAttributes <ValidateArgumentsAttribute>();
            var executionContext   = LocalPipeline.GetExecutionContextFromTLS();
            var engineIntrinsics   = executionContext == null ? null : executionContext.EngineIntrinsics;

            foreach (var validateAttribute in validateAttributes)
            {
                validateAttribute.InternalValidate(value, engineIntrinsics);
            }
        }
Beispiel #19
0
        internal SessionState(SessionStateInternal parent, bool createAsChild, bool linkToGlobal)
        {
            ExecutionContext executionContextFromTls = LocalPipeline.GetExecutionContextFromTLS();

            if (executionContextFromTls == null)
            {
                throw new InvalidOperationException("ExecutionContext");
            }
            this.sessionState = !createAsChild ? new SessionStateInternal(executionContextFromTls) : new SessionStateInternal(parent, linkToGlobal, executionContextFromTls);
            this.sessionState.PublicSessionState = this;
        }
        internal void DebuggerCheckVariableWrite()
        {
            var context = SessionState != null
                              ? SessionState.ExecutionContext
                              : LocalPipeline.GetExecutionContextFromTLS();

            if (context != null && context._debuggingMode > 0)
            {
                context.Debugger.CheckVariableWrite(Name);
            }
        }
Beispiel #21
0
 public PSModuleInfo(bool linkToGlobal)
 {
     this._context = LocalPipeline.GetExecutionContextFromTLS();
     if (this._context == null)
     {
         throw new InvalidOperationException(nameof(PSModuleInfo));
     }
     PSModuleInfo.SetDefaultDynamicNameAndPath(this);
     this._sessionState = new SessionState(this._context.EngineSessionState, true, linkToGlobal);
     this._sessionState.Internal.Module = this;
 }
Beispiel #22
0
 internal static bool IsStrictVersion(ExecutionContext context, int majorVersion)
 {
     if (context == null)
     {
         context = LocalPipeline.GetExecutionContextFromTLS();
     }
     if (context == null)
     {
         return(false);
     }
     return(context.IsStrictVersion(majorVersion));
 }
Beispiel #23
0
        internal static SteppablePipeline GetSteppablePipeline(PipelineAst pipelineAst, CommandOrigin commandOrigin)
        {
            PipelineProcessor pipe = new PipelineProcessor();

            System.Management.Automation.ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
            foreach (CommandAst ast in pipelineAst.PipelineElements.Cast <CommandAst>())
            {
                List <CommandParameterInternal> list = new List <CommandParameterInternal>();
                foreach (CommandElementAst ast2 in ast.CommandElements)
                {
                    CommandParameterAst commandParameterAst = ast2 as CommandParameterAst;
                    if (commandParameterAst != null)
                    {
                        list.Add(GetCommandParameter(commandParameterAst, executionContextFromTLS));
                    }
                    else
                    {
                        ExpressionAst expressionAst = (ExpressionAst)ast2;
                        object        obj2          = Compiler.GetExpressionValue(expressionAst, executionContextFromTLS, (IList)null);
                        bool          splatted      = (expressionAst is VariableExpressionAst) && ((VariableExpressionAst)expressionAst).Splatted;
                        list.Add(CommandParameterInternal.CreateArgument(expressionAst.Extent, obj2, splatted));
                    }
                }
                List <CommandRedirection> list2 = new List <CommandRedirection>();
                foreach (RedirectionAst ast5 in ast.Redirections)
                {
                    list2.Add(GetCommandRedirection(ast5, executionContextFromTLS));
                }
                CommandProcessorBase base2 = AddCommand(pipe, list.ToArray(), ast, list2.ToArray(), executionContextFromTLS);
                base2.Command.CommandOriginInternal      = commandOrigin;
                base2.CommandScope.ScopeOrigin           = commandOrigin;
                base2.Command.MyInvocation.CommandOrigin = commandOrigin;
                CallStackFrame[] frameArray = executionContextFromTLS.Debugger.GetCallStack().ToArray <CallStackFrame>();
                if ((frameArray.Length > 0) && Regex.IsMatch(frameArray[0].Position.Text, "GetSteppablePipeline", RegexOptions.IgnoreCase))
                {
                    InvocationInfo myInvocation = base2.Command.MyInvocation;
                    myInvocation.InvocationName = frameArray[0].InvocationInfo.InvocationName;
                    if (frameArray.Length > 1)
                    {
                        IScriptExtent position = frameArray[1].Position;
                        if ((position != null) && (position != PositionUtilities.EmptyExtent))
                        {
                            myInvocation.DisplayScriptPosition = position;
                        }
                    }
                }
                if ((executionContextFromTLS.CurrentCommandProcessor != null) && (executionContextFromTLS.CurrentCommandProcessor.CommandRuntime != null))
                {
                    base2.CommandRuntime.SetMergeFromRuntime(executionContextFromTLS.CurrentCommandProcessor.CommandRuntime);
                }
            }
            return(new SteppablePipeline(executionContextFromTLS, pipe));
        }
Beispiel #24
0
 public WmiBaseCmdlet()
 {
     string[] strArrays = new string[1];
     strArrays[0]             = "localhost";
     this.computerName        = strArrays;
     this.nameSpace           = "root\\cimv2";
     this.impersonationLevel  = ImpersonationLevel.Impersonate;
     this.authenticationLevel = AuthenticationLevel.Packet;
     this.async         = false;
     this.throttleLimit = WmiBaseCmdlet.DEFAULT_THROTTLE_LIMIT;
     this._context      = LocalPipeline.GetExecutionContextFromTLS();
 }
Beispiel #25
0
        public PSModuleInfo(ScriptBlock scriptBlock)
        {
            this._name                         = string.Empty;
            this._path                         = string.Empty;
            this._description                  = string.Empty;
            this._version                      = new System.Version(0, 0);
            this._detectedFunctionExports      = new List <string>();
            this._detectedWorkflowExports      = new List <string>();
            this._detectedCmdletExports        = new List <string>();
            this._compiledExports              = new List <CmdletInfo>();
            this._fileList                     = new List <string>();
            this._moduleList                   = new Collection <object>();
            this._nestedModules                = new List <PSModuleInfo>();
            this._scripts                      = new List <string>();
            this._requiredAssemblies           = new Collection <string>();
            this._requiredModules              = new List <PSModuleInfo>();
            this._requiredModulesSpecification = new List <ModuleSpecification>();
            this._detectedAliasExports         = new Dictionary <string, string>();
            this._exportedFormatFiles          = new ReadOnlyCollection <string>(new List <string>());
            this._exportedTypeFiles            = new ReadOnlyCollection <string>(new List <string>());
            if (scriptBlock == null)
            {
                throw PSTraceSource.NewArgumentException("scriptBlock");
            }
            ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();

            if (executionContextFromTLS == null)
            {
                throw new InvalidOperationException("PSModuleInfo");
            }
            SetDefaultDynamicNameAndPath(this);
            this._sessionState = new System.Management.Automation.SessionState(executionContextFromTLS, true, true);
            this._sessionState.Internal.Module = this;
            SessionStateInternal engineSessionState = executionContextFromTLS.EngineSessionState;

            try
            {
                executionContextFromTLS.EngineSessionState = this._sessionState.Internal;
                executionContextFromTLS.SetVariable(SpecialVariables.PSScriptRootVarPath, this._path);
                scriptBlock = scriptBlock.Clone(true);
                scriptBlock.SessionState = this._sessionState;
                Pipe outputPipe = new Pipe {
                    NullPipe = true
                };
                scriptBlock.InvokeWithPipe(false, ScriptBlock.ErrorHandlingBehavior.WriteToCurrentErrorPipe, AutomationNull.Value, AutomationNull.Value, AutomationNull.Value, outputPipe, null, new object[0]);
            }
            finally
            {
                executionContextFromTLS.EngineSessionState = engineSessionState;
            }
        }
Beispiel #26
0
        internal static BindingRestrictions GetLanguageModeCheckIfHasEverUsedConstrainedLanguage()
        {
            BindingRestrictions empty = BindingRestrictions.Empty;

            if (!ExecutionContext.HasEverUsedConstrainedLanguage)
            {
                return(empty);
            }
            if (LocalPipeline.GetExecutionContextFromTLS().LanguageMode == PSLanguageMode.ConstrainedLanguage)
            {
                return(BindingRestrictions.GetExpressionRestriction(Expression.Equal(Expression.Property(ExpressionCache.GetExecutionContextFromTLS, CachedReflectionInfo.ExecutionContext_LanguageMode), Expression.Constant(PSLanguageMode.ConstrainedLanguage))));
            }
            return(BindingRestrictions.GetExpressionRestriction(Expression.NotEqual(Expression.Property(ExpressionCache.GetExecutionContextFromTLS, CachedReflectionInfo.ExecutionContext_LanguageMode), Expression.Constant(PSLanguageMode.ConstrainedLanguage))));
        }
Beispiel #27
0
        internal static TypeResolutionState GetDefaultUsingState(ExecutionContext context)
        {
            if (context == null)
            {
                context = LocalPipeline.GetExecutionContextFromTLS();
            }

            if (context != null)
            {
                return(context.EngineSessionState.CurrentScope.TypeResolutionState);
            }

            return(TypeResolutionState.UsingSystem);
        }
        internal ScriptBlockAst GetScriptBlockAst()
        {
            var scriptContents = ScriptContents;

            if (_scriptBlock == null)
            {
                this.ScriptBlock = ScriptBlock.TryGetCachedScriptBlock(_path, scriptContents);
            }

            if (_scriptBlock != null)
            {
                return((ScriptBlockAst)_scriptBlock.Ast);
            }

            if (_scriptBlockAst == null)
            {
                ParseError[] errors;
                Parser       parser = new Parser();

                // If we are in ConstrainedLanguage mode but the defining language mode is FullLanguage, then we need
                // to parse the script contents in FullLanguage mode context.  Otherwise we will get bogus parsing errors
                // such as "Configuration or Class keyword not allowed".
                var context = LocalPipeline.GetExecutionContextFromTLS();
                if (context != null && context.LanguageMode == PSLanguageMode.ConstrainedLanguage &&
                    DefiningLanguageMode == PSLanguageMode.FullLanguage)
                {
                    context.LanguageMode = PSLanguageMode.FullLanguage;
                    try
                    {
                        _scriptBlockAst = parser.Parse(_path, ScriptContents, null, out errors, ParseMode.Default);
                    }
                    finally
                    {
                        context.LanguageMode = PSLanguageMode.ConstrainedLanguage;
                    }
                }
                else
                {
                    _scriptBlockAst = parser.Parse(_path, ScriptContents, null, out errors, ParseMode.Default);
                }

                if (errors.Length == 0)
                {
                    this.ScriptBlock = new ScriptBlock(_scriptBlockAst, isFilter: false);
                    ScriptBlock.CacheScriptBlock(_scriptBlock.Clone(), _path, scriptContents);
                }
            }

            return(_scriptBlockAst);
        }
Beispiel #29
0
        internal static object GetNonIndexable(object target, object[] indices)
        {
            if (indices.Length == 1)
            {
                object second = indices[0];
                if ((second != null) && (LanguagePrimitives.Equals(0, second) || LanguagePrimitives.Equals(-1, second)))
                {
                    return(target);
                }
            }
            ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();

            if ((executionContextFromTLS != null) && executionContextFromTLS.IsStrictVersion(2))
            {
                throw InterpreterError.NewInterpreterException(target, typeof(RuntimeException), null, "CannotIndex", ParserStrings.CannotIndex, new object[] { target.GetType() });
            }
            return(AutomationNull.Value);
        }
Beispiel #30
0
 internal static void CheckForSevereException(Exception e)
 {
     if ((e is AccessViolationException) || (e is StackOverflowException))
     {
         try
         {
             if (!alreadyFailing)
             {
                 alreadyFailing = true;
                 MshLog.LogCommandHealthEvent(LocalPipeline.GetExecutionContextFromTLS(), e, Severity.Critical);
             }
         }
         finally
         {
             WindowsErrorReporting.FailFast(e);
         }
     }
 }