public override AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
 {
     if (dataStatementAst.Variable != null)
     {
         this.NoteVariable(dataStatementAst.Variable, -1, null, false, false);
     }
     return(AstVisitAction.Continue);
 }
Esempio n. 2
0
        public override AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
        {
            IEnumerable <string>      allowedCommands = dataStatementAst.HasNonConstantAllowedCommand ? null : GetConstantDataStatementAllowedCommands(dataStatementAst);
            RestrictedLanguageChecker visitor         = new RestrictedLanguageChecker(this._parser, allowedCommands, null, false);

            dataStatementAst.Body.InternalVisit(visitor);
            return(AstVisitAction.Continue);
        }
Esempio n. 3
0
 public object VisitDataStatement(DataStatementAst dataStatementAst)
 {
     dataStatementAst.Body.Accept(this);
     if (dataStatementAst.Variable != null)
     {
         this._currentBlock.AddAst(dataStatementAst);
     }
     return(null);
 }
Esempio n. 4
0
        private static IEnumerable <string> GetConstantDataStatementAllowedCommands(DataStatementAst dataStatementAst)
        {
            yield return("ConvertFrom-StringData");

            foreach (ExpressionAst iteratorVariable0 in dataStatementAst.CommandsAllowed)
            {
                yield return(((StringConstantExpressionAst)iteratorVariable0).Value);
            }
        }
Esempio n. 5
0
 internal static void CheckDataStatementAstAtRuntime(DataStatementAst dataStatementAst, string[] allowedCommands)
 {
     Parser parser = new Parser();
     RestrictedLanguageChecker visitor = new RestrictedLanguageChecker(parser, allowedCommands, null, false);
     dataStatementAst.Body.InternalVisit(visitor);
     if (parser.ErrorList.Any<ParseError>())
     {
         throw new ParseException(parser.ErrorList.ToArray());
     }
 }
        internal static void CheckDataStatementAstAtRuntime(DataStatementAst dataStatementAst, string[] allowedCommands)
        {
            Parser parser = new Parser();
            RestrictedLanguageChecker visitor = new RestrictedLanguageChecker(parser, allowedCommands, null, false);

            dataStatementAst.Body.InternalVisit(visitor);
            if (parser.ErrorList.Any <ParseError>())
            {
                throw new ParseException(parser.ErrorList.ToArray());
            }
        }
Esempio n. 7
0
 private void AnalyzeBlock(BitArray assignedBitArray, Block block)
 {
     foreach (Ast ast in block._asts)
     {
         VariableExpressionAst ast2 = ast as VariableExpressionAst;
         if (ast2 != null)
         {
             VariablePath variablePath = ast2.VariablePath;
             if (variablePath.IsAnyLocal())
             {
                 string unaliasedVariableName    = GetUnaliasedVariableName(variablePath);
                 VariableAnalysisDetails details = this._variables[unaliasedVariableName];
                 if (details.Automatic)
                 {
                     ast2.TupleIndex = details.LocalTupleIndex;
                     ast2.Automatic  = true;
                 }
                 else
                 {
                     ast2.TupleIndex = (assignedBitArray[details.BitIndex] && !details.PreferenceVariable) ? details.LocalTupleIndex : -2;
                 }
             }
         }
         else
         {
             AssignmentTarget target = ast as AssignmentTarget;
             if (target != null)
             {
                 if (target._targetAst != null)
                 {
                     this.CheckLHSAssign(target._targetAst, assignedBitArray);
                 }
                 else
                 {
                     this.CheckLHSAssignVar(target._variableName, assignedBitArray, target._type);
                 }
             }
             else
             {
                 DataStatementAst item = ast as DataStatementAst;
                 if (item != null)
                 {
                     VariableAnalysisDetails details2 = this.CheckLHSAssignVar(item.Variable, assignedBitArray, typeof(object));
                     item.TupleIndex = details2.LocalTupleIndex;
                     details2.AssociatedAsts.Add(item);
                 }
             }
         }
     }
 }
Esempio n. 8
0
    public System.Object VisitDataStatement(System.Management.Automation.Language.DataStatementAst dataStatementAst)
    {
        IScriptExtent mappedExtent = MapExtent(dataStatementAst.Extent);

        LinkedList <ExpressionAst> mappedCommandsAllowed = new LinkedList <ExpressionAst>();

        foreach (ExpressionAst e in dataStatementAst.CommandsAllowed)
        {
            mappedCommandsAllowed.AddLast(_VisitExpression(e));
        }
        StatementBlockAst mappedBody = (StatementBlockAst)VisitStatementBlock(dataStatementAst.Body);


        return(new DataStatementAst(mappedExtent, dataStatementAst.Variable, mappedCommandsAllowed, mappedBody));
    }
Esempio n. 9
0
        private static void FixTupleIndex(Ast ast, int newIndex)
        {
            VariableExpressionAst ast2 = ast as VariableExpressionAst;

            if (ast2 != null)
            {
                if (ast2.TupleIndex != -2)
                {
                    ast2.TupleIndex = newIndex;
                }
            }
            else
            {
                DataStatementAst ast3 = ast as DataStatementAst;
                if ((ast3 != null) && (ast3.TupleIndex != -2))
                {
                    ast3.TupleIndex = newIndex;
                }
            }
        }
Esempio n. 10
0
 public object VisitDataStatement(DataStatementAst dataStatementAst)
 {
     return(false);
 }
Esempio n. 11
0
 /// <summary/>
 public virtual AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst) => DefaultVisit(dataStatementAst);
Esempio n. 12
0
 /// <summary/>
 public virtual object VisitDataStatement(DataStatementAst dataStatementAst) { return null; }
Esempio n. 13
0
 public virtual AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
 {
     return AstVisitAction.Continue;
 }
        /// <summary>
        /// Visit data statement
        /// </summary>
        /// <param name="dataStatementAst"></param>
        /// <returns></returns>
        public object VisitDataStatement(DataStatementAst dataStatementAst)
        {
            if (dataStatementAst == null) return null;

            dataStatementAst.Body.Visit(this.Decorator);
            if (dataStatementAst.Variable != null)
            {
                _currentBlock.AddAst(new AssignmentTarget(dataStatementAst.Variable, null));
            }
            return null;
        }
 public override AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
 {
     this.ReportError(dataStatementAst, () => ParserStrings.DataSectionStatementNotSupportedInDataSection, new object[0]);
     return(AstVisitAction.Continue);
 }
 public object VisitDataStatement(DataStatementAst dataStatementAst) { throw new UnexpectedElementException(); }
Esempio n. 17
0
        public override AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
        {
            IEnumerable<string> allowedCommands =
                dataStatementAst.HasNonConstantAllowedCommand ? null : GetConstantDataStatementAllowedCommands(dataStatementAst);
            RestrictedLanguageChecker checker = new RestrictedLanguageChecker(_parser, allowedCommands, null, false);
            dataStatementAst.Body.InternalVisit(checker);

            return AstVisitAction.Continue;
        }
Esempio n. 18
0
 private static IEnumerable<string> GetConstantDataStatementAllowedCommands(DataStatementAst dataStatementAst)
 {
     yield return "ConvertFrom-StringData";
     foreach (var allowed in dataStatementAst.CommandsAllowed)
     {
         yield return ((StringConstantExpressionAst)allowed).Value;
     }
 }
Esempio n. 19
0
 internal static void CheckDataStatementLanguageModeAtRuntime(DataStatementAst dataStatementAst, ExecutionContext executionContext)
 {
     // If we get here, we have already determined the data statement invokes commands, so
     // we only need to check the language mode.
     if (executionContext.LanguageMode == PSLanguageMode.ConstrainedLanguage)
     {
         var parser = new Parser();
         parser.ReportError(dataStatementAst.CommandsAllowed[0].Extent, () => ParserStrings.DataSectionAllowedCommandDisallowed);
         throw new ParseException(parser.ErrorList.ToArray());
     }
 }
Esempio n. 20
0
 public override AstVisitAction VisitDataStatement(DataStatementAst ast) { return CheckParent(ast); }
        /// <summary>
        /// Visit datastatement
        /// </summary>
        /// <param name="dataStatementAst"></param>
        /// <returns></returns>
        public override AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
        {
            if (dataStatementAst != null && dataStatementAst.Variable != null)
            {
                NoteVariable(dataStatementAst.Variable, null);
            }

            return AstVisitAction.Continue;
        }
Esempio n. 22
0
 public override AstVisitAction VisitDataStatement(DataStatementAst ast)
 {
     return this.Check(ast);
 }
 /// <summary/>
 public virtual object VisitDataStatement(DataStatementAst dataStatementAst)
 {
     return _decorated.VisitDataStatement(dataStatementAst);
 }
Esempio n. 24
0
 public object VisitDataStatement(DataStatementAst dataStatementAst) { return AutomationNull.Value; }
Esempio n. 25
0
 public override AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
 {
     throw new NotImplementedException(); //VisitDataStatement(dataStatementAst);
 }
Esempio n. 26
0
 public object VisitDataStatement(DataStatementAst dataStatementAst) { throw PSTraceSource.NewArgumentException("ast"); }
Esempio n. 27
0
 public override AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
 {
     if (dataStatementAst.Variable != null)
     {
         this.NoteVariable(dataStatementAst.Variable, -1, null, false, false);
     }
     return AstVisitAction.Continue;
 }
Esempio n. 28
0
 public override AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst) { return AstVisitAction.SkipChildren; }
Esempio n. 29
0
 public override AstVisitAction VisitDataStatement(DataStatementAst ast)
 {
     return(Check(ast));
 }
Esempio n. 30
0
 public object VisitDataStatement(DataStatementAst dataStatementAst)
 {
     throw PSTraceSource.NewArgumentException("ast");
 }
Esempio n. 31
0
        public object VisitDataStatement(DataStatementAst dataStatementAst)
        {
            // We'll generate the following:
            //
            // try
            // {
            //     oldLanguageMode = context.LanguageMode;
            //     CheckLanguageMode (if necessary, only if SupportedCommands specified)
            //     CheckAllowedCommands (if necessary, it may have been done at parse time if possible)
            //     context.LanguageMode = PSLanguageMode.RestrictedLanguage;
            //     either:
            //         dataStatementAst.Variable = execute body
            //     or if the variable name was not specified:
            //         execute body, writing results to the current output pipe
            // }
            // finally
            // {
            //     context.LanguageMode = oldLanguageMode;
            // }

            var oldLanguageMode = NewTemp(typeof(PSLanguageMode), "oldLanguageMode");
            var languageModePropertyExpr = Expression.Property(_executionContextParameter, CachedReflectionInfo.ExecutionContext_LanguageMode);

            var exprs = new List<Expression>
                {
                    // Save old language mode before doing anything else so if there is an exception, we don't
                    // "restore" the language mode to an uninitialized value (which happens to be "full" mode.
                    Expression.Assign(oldLanguageMode, languageModePropertyExpr),

                    UpdatePosition(dataStatementAst),

                    // Auto-import utility module if needed, so that ConvertFrom-StringData isn't set to RestrictedLanguage
                    // by the data section.
                    Expression.Call(CachedReflectionInfo.RestrictedLanguageChecker_EnsureUtilityModuleLoaded,
                                    _executionContextParameter)
                };

            if (dataStatementAst.CommandsAllowed.Count > 0)
            {
                // If CommandsAllowed was specified, we need to check the language mode - the data section runs
                // in restricted language mode and we don't want to allow disallowed commands to run if we were in
                // constrained language mode.
                exprs.Add(
                    Expression.Call(
                        CachedReflectionInfo.RestrictedLanguageChecker_CheckDataStatementLanguageModeAtRuntime,
                        Expression.Constant(dataStatementAst), _executionContextParameter));
            }

            if (dataStatementAst.HasNonConstantAllowedCommand)
            {
                // We couldn't check the commands allowed at parse time, so we must do so at runtime
                exprs.Add(
                    Expression.Call(CachedReflectionInfo.RestrictedLanguageChecker_CheckDataStatementAstAtRuntime,
                                    Expression.Constant(dataStatementAst),
                                    Expression.NewArrayInit(typeof(string),
                                                            dataStatementAst.CommandsAllowed.Select(
                                                                elem => Compile(elem).Convert(typeof(string))))));
            }

            exprs.Add(Expression.Assign(languageModePropertyExpr, Expression.Constant(PSLanguageMode.RestrictedLanguage)));

            // If we'll be assigning directly, we need to capture the value, otherwise just write to the current output pipe.
            // We should not preserve the partial output if exception is thrown when evaluating the body expr.
            var dataExpr = dataStatementAst.Variable != null
                               ? CaptureAstResults(dataStatementAst.Body, CaptureAstContext.AssignmentWithoutResultPreservation).Cast(typeof(object))
                               : Compile(dataStatementAst.Body);
            exprs.Add(dataExpr);

            var block = Expression.Block(
                new[] { oldLanguageMode },
                Expression.TryFinally(
                    Expression.Block(exprs),
                    Expression.Assign(languageModePropertyExpr, oldLanguageMode)));

            if (dataStatementAst.Variable != null)
            {
                return dataStatementAst.TupleIndex < 0
                    ? CallSetVariable(Expression.Constant(new VariablePath("local:" + dataStatementAst.Variable)), block)
                    : Expression.Assign(GetLocal(dataStatementAst.TupleIndex), block);
            }

            return block;
        }
Esempio n. 32
0
 public object VisitDataStatement(DataStatementAst dataStatementAst)
 {
     Func<ExpressionAst, Expression> selector = null;
     List<Expression> expressions = new List<Expression> {
         this.UpdatePosition(dataStatementAst)
     };
     if (dataStatementAst.HasNonConstantAllowedCommand)
     {
         if (selector == null)
         {
             selector = elem => this.Compile(elem).Convert(typeof(string));
         }
         expressions.Add(Expression.Call(CachedReflectionInfo.RestrictedLanguageChecker_CheckDataStatementAstAtRuntime, Expression.Constant(dataStatementAst), Expression.NewArrayInit(typeof(string), dataStatementAst.CommandsAllowed.Select<ExpressionAst, Expression>(selector))));
     }
     ParameterExpression left = this.NewTemp(typeof(PSLanguageMode), "oldLanguageMode");
     MemberExpression right = Expression.Property(_executionContextParameter, CachedReflectionInfo.ExecutionContext_LanguageMode);
     expressions.Add(Expression.Assign(left, right));
     expressions.Add(Expression.Assign(right, Expression.Constant(PSLanguageMode.RestrictedLanguage)));
     Expression item = (dataStatementAst.Variable != null) ? this.CaptureAstResults(dataStatementAst.Body, CaptureAstContext.Assignment, null).Cast(typeof(object)) : this.Compile(dataStatementAst.Body);
     expressions.Add(item);
     BlockExpression expression4 = Expression.Block(new ParameterExpression[] { left }, new Expression[] { Expression.TryFinally(Expression.Block(expressions), Expression.Assign(right, left)) });
     if (dataStatementAst.Variable == null)
     {
         return expression4;
     }
     if (dataStatementAst.TupleIndex >= 0)
     {
         return Expression.Assign(this.GetLocal(dataStatementAst.TupleIndex), expression4);
     }
     return CallSetVariable(Expression.Constant(new VariablePath("local:" + dataStatementAst.Variable)), expression4, null);
 }
Esempio n. 33
0
 /// <summary/>
 public virtual object VisitDataStatement(DataStatementAst dataStatementAst)
 {
     return(null);
 }
Esempio n. 34
0
        public override AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
        {
            if (dataStatementAst.Variable != null)
            {
                NoteVariable(dataStatementAst.Variable, VariableAnalysis.Unanalyzed, null);
            }

            return AstVisitAction.Continue;
        }
Esempio n. 35
0
 public object VisitDataStatement(DataStatementAst dataStatementAst)
 {
     return false;
 }
Esempio n. 36
0
 public override AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
 {
     this.ReportError(dataStatementAst, () => ParserStrings.DataSectionStatementNotSupportedInDataSection, new object[0]);
     return AstVisitAction.Continue;
 }
Esempio n. 37
0
 /// <summary/>
 public virtual AstVisitAction VisitDataStatement(DataStatementAst dataStatementAst)
 {
     return(AstVisitAction.Continue);
 }
Esempio n. 38
0
 public object VisitDataStatement(DataStatementAst dataStatementAst)
 {
     dataStatementAst.Body.Accept(this);
     if (dataStatementAst.Variable != null)
     {
         this._currentBlock.AddAst(dataStatementAst);
     }
     return null;
 }
Esempio n. 39
0
 public object VisitDataStatement(DataStatementAst dataStatementAst)
 {
     return(AutomationNull.Value);
 }
 public object VisitDataStatement(DataStatementAst dataStatementAst)
 {
     throw new NotImplementedException();
 }