public override AstVisitAction VisitPipeline(PipelineAst pipelineAst) { if (pipelineAst.PipelineElements[0] is CommandExpressionAst) { // If the first element is a CommandExpression, this pipeline should be the value // of a parameter. We want to avoid a scriptblock that contains only a pure expression. // The check "pipelineAst.Parent.Parent == ScriptBeingConverted" guarantees we throw // error on that kind of scriptblock. // Disallow pure expressions at the "top" level, but allow them otherwise. // We want to catch: // 1 | echo // But we don't want to error out on: // echo $(1) // See the comment in VisitCommand on why it's safe to check Parent.Parent, we // know that we have at least: // * a NamedBlockAst (the end block) // * a ScriptBlockAst (the ast we're comparing to) if (pipelineAst.GetPureExpression() == null || pipelineAst.Parent.Parent == ScriptBeingConverted) { ThrowError( new ScriptBlockToPowerShellNotSupportedException( "CantConvertPipelineStartsWithExpression", null, AutomationExceptions.CantConvertPipelineStartsWithExpression), pipelineAst); } } return AstVisitAction.Continue; }
public override AstVisitAction VisitPipeline(PipelineAst pipelineAst) { if ((pipelineAst.PipelineElements[0] is CommandExpressionAst) && ((pipelineAst.GetPureExpression() == null) || (pipelineAst.Parent.Parent == this.ScriptBeingConverted))) { ThrowError(new ScriptBlockToPowerShellNotSupportedException("CantConvertPipelineStartsWithExpression", null, AutomationExceptions.CantConvertPipelineStartsWithExpression, new object[0]), pipelineAst); } return AstVisitAction.Continue; }
public object VisitPipeline(PipelineAst pipelineAst) { var expr = pipelineAst.GetPureExpression(); if (expr != null) { return expr.Visit(this); } throw new UnexpectedElementException(); }
public System.Object VisitPipeline(System.Management.Automation.Language.PipelineAst pipelineAst) { IScriptExtent mappedExtent = MapExtent(pipelineAst.Extent); LinkedList <CommandBaseAst> mappedPipelineElements = new LinkedList <CommandBaseAst>(); foreach (CommandBaseAst cb in pipelineAst.PipelineElements) { mappedPipelineElements.AddLast(_VisitCommandBase(cb)); } return(new PipelineAst(mappedExtent, mappedPipelineElements)); }
public override AstVisitAction VisitPipeline(PipelineAst pipelineAst) { if (this.lineNumber == pipelineAst.Extent.StartLineNumber) { // Which command is the cursor in? foreach (var commandAst in pipelineAst.PipelineElements.OfType<CommandAst>()) { int trueEndColumnNumber = commandAst.Extent.EndColumnNumber; string currentLine = commandAst.Extent.StartScriptPosition.Line; if (currentLine.Length >= trueEndColumnNumber) { // Get the text left in the line after the command's extent string remainingLine = currentLine.Substring( commandAst.Extent.EndColumnNumber); // Calculate the "true" end column number by finding out how many // whitespace characters are between this command and the next (or // the end of the line). // NOTE: +1 is added to trueEndColumnNumber to account for the position // just after the last character in the command string or script line. int preTrimLength = remainingLine.Length; int postTrimLength = remainingLine.TrimStart().Length; trueEndColumnNumber = commandAst.Extent.EndColumnNumber + (preTrimLength - postTrimLength) + 1; } if (commandAst.Extent.StartColumnNumber <= columnNumber && trueEndColumnNumber >= columnNumber) { this.FoundCommandReference = new SymbolReference( SymbolType.Function, commandAst.CommandElements[0].Extent); return AstVisitAction.StopVisit; } } } return base.VisitPipeline(pipelineAst); }
public override AstVisitAction VisitPipeline(PipelineAst ast) { return CheckParent(ast); }
/// <summary/> public virtual object VisitPipeline(PipelineAst pipelineAst) { return(null); }
public object VisitPipeline(PipelineAst pipelineAst) { bool flag = false; foreach (CommandBaseAst ast in pipelineAst.PipelineElements) { ast.Accept(this); if (ast is CommandAst) { flag = true; } foreach (RedirectionAst ast2 in ast.Redirections) { ast2.Accept(this); } } if (flag && this._loopTargets.Any<LoopGotoTargets>()) { foreach (LoopGotoTargets targets in this._loopTargets) { this._currentBlock.FlowsTo(targets.BreakTarget); this._currentBlock.FlowsTo(targets.ContinueTarget); } Block next = new Block(); this._currentBlock.FlowsTo(next); this._currentBlock = next; } return null; }
/// <summary/> public virtual object VisitPipeline(PipelineAst pipelineAst) { return _decorated.VisitPipeline(pipelineAst); }
public object VisitPipeline(PipelineAst pipelineAst) { var temps = new List<ParameterExpression>(); var exprs = new List<Expression>(); if (!(pipelineAst.Parent is AssignmentStatementAst || pipelineAst.Parent is ParenExpressionAst)) { // If the parent is an assignment, we've already added a sequence point, don't add another. exprs.Add(UpdatePosition(pipelineAst)); } var pipeElements = pipelineAst.PipelineElements; var firstCommandExpr = (pipeElements[0] as CommandExpressionAst); if (firstCommandExpr != null && pipeElements.Count == 1) { if (firstCommandExpr.Redirections.Count > 0) { exprs.Add(GetRedirectedExpression(firstCommandExpr, captureForInput: false)); } else { exprs.Add(Compile(firstCommandExpr)); } } else { Expression input; int i, commandsInPipe; if (firstCommandExpr != null) { if (firstCommandExpr.Redirections.Count > 0) { input = GetRedirectedExpression(firstCommandExpr, captureForInput: true); } else { input = GetRangeEnumerator(firstCommandExpr.Expression) ?? Compile(firstCommandExpr.Expression); } i = 1; commandsInPipe = pipeElements.Count - 1; } else { // Compiled code normally never sees AutomationNull. We use that value // here so that we can tell the difference b/w $null and no input when // starting the pipeline, in other words, PipelineOps.InvokePipe will // not pass this value to the pipe. input = ExpressionCache.AutomationNullConstant; i = 0; commandsInPipe = pipeElements.Count; } Expression[] pipelineExprs = new Expression[commandsInPipe]; CommandBaseAst[] pipeElementAsts = new CommandBaseAst[commandsInPipe]; var commandRedirections = new object[commandsInPipe]; for (int j = 0; i < pipeElements.Count; ++i, ++j) { var pipeElement = pipeElements[i]; pipelineExprs[j] = Compile(pipeElement); commandRedirections[j] = GetCommandRedirections(pipeElement); pipeElementAsts[j] = pipeElement; } // The redirections are passed as a CommandRedirection[][] - one dimension for each command in the pipe, // one dimension because each command may have multiple redirections. Here we create the array for // each command in the pipe, either a compile time constant or created at runtime if necessary. Expression redirectionExpr; if (commandRedirections.Any(r => r is Expression)) { // If any command redirections are non-constant, commandRedirections will have a Linq.Expression in it, // in which case we must create the array at runtime redirectionExpr = Expression.NewArrayInit(typeof(CommandRedirection[]), commandRedirections.Select(r => (r as Expression) ?? Expression.Constant(r, typeof(CommandRedirection[])))); } else if (commandRedirections.Any(r => r != null)) { // There were redirections, but all were compile time constant, so build the array at compile time. redirectionExpr = Expression.Constant(commandRedirections.Map(r => r as CommandRedirection[])); } else { // No redirections. redirectionExpr = ExpressionCache.NullCommandRedirections; } if (firstCommandExpr != null) { var inputTemp = Expression.Variable(input.Type); temps.Add(inputTemp); exprs.Add(Expression.Assign(inputTemp, input)); input = inputTemp; } Expression invokePipe = Expression.Call( CachedReflectionInfo.PipelineOps_InvokePipeline, input.Cast(typeof(object)), firstCommandExpr != null ? ExpressionCache.FalseConstant : ExpressionCache.TrueConstant, Expression.NewArrayInit(typeof(CommandParameterInternal[]), pipelineExprs), Expression.Constant(pipeElementAsts), redirectionExpr, _functionContext); exprs.Add(invokePipe); } return Expression.Block(temps, exprs); }
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); }
private StatementAst SwitchStatementRule(LabelToken labelToken, Token switchToken) { IScriptExtent extent = null; Token token; string labelText; IEnumerable<Ast> nestedErrorAsts; LabelToken labelToken1 = labelToken; Token token1 = labelToken1; if (labelToken1 == null) { token1 = switchToken; } IScriptExtent scriptExtent = token1.Extent; bool flag = false; bool flag1 = false; this.SkipNewlines(); bool flag2 = false; PipelineBaseAst pipelineAst = null; Dictionary<string, Tuple<Token, Ast>> strs = null; Token token2 = this.PeekToken(); SwitchFlags switchFlag = SwitchFlags.None; while (token2.Kind == TokenKind.Parameter) { this.SkipToken(); extent = token2.Extent; Dictionary<string, Tuple<Token, Ast>> strs1 = strs; Dictionary<string, Tuple<Token, Ast>> strs2 = strs1; if (strs1 == null) { strs2 = new Dictionary<string, Tuple<Token, Ast>>(); } strs = strs2; if (!Parser.IsSpecificParameter(token2, "regex")) { if (!Parser.IsSpecificParameter(token2, "wildcard")) { if (!Parser.IsSpecificParameter(token2, "exact")) { if (!Parser.IsSpecificParameter(token2, "casesensitive")) { if (!Parser.IsSpecificParameter(token2, "parallel")) { if (!Parser.IsSpecificParameter(token2, "file")) { flag = true; object[] parameterName = new object[1]; parameterName[0] = ((ParameterToken)token2).ParameterName; this.ReportError(token2.Extent, ParserStrings.InvalidSwitchFlag, parameterName); } else { switchFlag = switchFlag | SwitchFlags.File; this.SkipNewlines(); ExpressionAst singleCommandArgument = this.GetSingleCommandArgument(Parser.CommandArgumentContext.FileName); if (singleCommandArgument != null) { extent = singleCommandArgument.Extent; pipelineAst = new PipelineAst(singleCommandArgument.Extent, new CommandExpressionAst(singleCommandArgument.Extent, singleCommandArgument, null)); if (!strs.ContainsKey("file")) { strs.Add("file", new Tuple<Token, Ast>(token2, pipelineAst)); } } else { flag = true; flag1 = this.ReportIncompleteInput(Parser.After(token2), ParserStrings.MissingFilenameOption, new object[0]); if (!strs.ContainsKey("file")) { strs.Add("file", new Tuple<Token, Ast>(token2, null)); } } } } else { switchFlag = switchFlag | SwitchFlags.Parallel; if (!strs.ContainsKey("parallel")) { strs.Add("parallel", new Tuple<Token, Ast>(token2, null)); } } } else { switchFlag = switchFlag | SwitchFlags.CaseSensitive; if (!strs.ContainsKey("casesensitive")) { strs.Add("casesensitive", new Tuple<Token, Ast>(token2, null)); } } } else { switchFlag = switchFlag & (SwitchFlags.File | SwitchFlags.Wildcard | SwitchFlags.Exact | SwitchFlags.CaseSensitive | SwitchFlags.Parallel); switchFlag = switchFlag & (SwitchFlags.File | SwitchFlags.Regex | SwitchFlags.Exact | SwitchFlags.CaseSensitive | SwitchFlags.Parallel); if (!strs.ContainsKey("exact")) { strs.Add("exact", new Tuple<Token, Ast>(token2, null)); } } } else { switchFlag = switchFlag | SwitchFlags.Wildcard; switchFlag = switchFlag & (SwitchFlags.File | SwitchFlags.Wildcard | SwitchFlags.Exact | SwitchFlags.CaseSensitive | SwitchFlags.Parallel); if (!strs.ContainsKey("wildcard")) { strs.Add("wildcard", new Tuple<Token, Ast>(token2, null)); } } } else { switchFlag = switchFlag | SwitchFlags.Regex; switchFlag = switchFlag & (SwitchFlags.File | SwitchFlags.Regex | SwitchFlags.Exact | SwitchFlags.CaseSensitive | SwitchFlags.Parallel); if (!strs.ContainsKey("regex")) { strs.Add("regex", new Tuple<Token, Ast>(token2, null)); } } token2 = this.PeekToken(); } if (token2.Kind == TokenKind.Minus) { Dictionary<string, Tuple<Token, Ast>> strs3 = strs; Dictionary<string, Tuple<Token, Ast>> strs4 = strs3; if (strs3 == null) { strs4 = new Dictionary<string, Tuple<Token, Ast>>(); } strs = strs4; strs.Add("--%", new Tuple<Token, Ast>(token2, null)); } Token token3 = this.PeekToken(); if (token3.Kind != TokenKind.LParen) { if (pipelineAst == null && (switchFlag & SwitchFlags.File) == SwitchFlags.None) { flag = true; flag1 = this.ReportIncompleteInput(Parser.After(extent), ParserStrings.PipelineValueRequired, new object[0]); } } else { extent = token3.Extent; this.SkipToken(); if ((switchFlag & SwitchFlags.File) == SwitchFlags.File) { flag = true; this.ReportError(token3.Extent, ParserStrings.PipelineValueRequired, new object[0]); } flag2 = true; this.SkipNewlines(); pipelineAst = this.PipelineRule(); if (pipelineAst != null) { extent = pipelineAst.Extent; } else { flag = true; flag1 = this.ReportIncompleteInput(Parser.After(token3), ParserStrings.PipelineValueRequired, new object[0]); } this.SkipNewlines(); Token token4 = this.NextToken(); if (token4.Kind == TokenKind.RParen) { extent = token4.Extent; } else { this.UngetToken(token4); if (!flag1) { flag = true; flag1 = this.ReportIncompleteInput(Parser.After(extent), ParserStrings.MissingEndParenthesisInSwitchStatement, new object[0]); } } } this.SkipNewlines(); Token token5 = this.NextToken(); StatementBlockAst statementBlockAst = null; List<Tuple<ExpressionAst, StatementBlockAst>> tuples = new List<Tuple<ExpressionAst, StatementBlockAst>>(); List<Ast> asts = new List<Ast>(); Token token6 = null; if (token5.Kind == TokenKind.LCurly) { extent = token5.Extent; this.SkipNewlines(); do { ExpressionAst expressionAst = this.GetSingleCommandArgument(Parser.CommandArgumentContext.SwitchCondition); if (expressionAst != null) { asts.Add(expressionAst); extent = expressionAst.Extent; StatementBlockAst statementBlockAst1 = this.StatementBlockRule(); if (statementBlockAst1 != null) { asts.Add(statementBlockAst1); extent = statementBlockAst1.Extent; StringConstantExpressionAst stringConstantExpressionAst = expressionAst as StringConstantExpressionAst; if (stringConstantExpressionAst == null || stringConstantExpressionAst.StringConstantType != StringConstantType.BareWord || !stringConstantExpressionAst.Value.Equals("default", StringComparison.OrdinalIgnoreCase)) { tuples.Add(new Tuple<ExpressionAst, StatementBlockAst>(expressionAst, statementBlockAst1)); } else { if (statementBlockAst != null) { flag = true; this.ReportError(expressionAst.Extent, ParserStrings.MultipleSwitchDefaultClauses, new object[0]); } statementBlockAst = statementBlockAst1; } } else { flag = true; flag1 = this.ReportIncompleteInput(Parser.After(extent), ParserStrings.MissingSwitchStatementClause, new object[0]); } this.SkipNewlinesAndSemicolons(); token = this.PeekToken(); if (token.Kind != TokenKind.RCurly) { continue; } token6 = token; this.SkipToken(); goto Label0; } else { flag = true; this.ReportIncompleteInput(Parser.After(extent), ParserStrings.MissingSwitchConditionExpression, new object[0]); if (this.PeekToken().Kind != TokenKind.RCurly) { goto Label0; } this.SkipToken(); goto Label0; } } while (token.Kind != TokenKind.EndOfInput); if (!flag1) { flag = true; this.ReportIncompleteInput(token5.Extent, token.Extent, ParserStrings.MissingEndCurlyBrace, new object[0]); } } else { this.UngetToken(token5); if (!flag1) { flag = true; this.ReportIncompleteInput(Parser.After(extent), ParserStrings.MissingCurlyBraceInSwitchStatement, new object[0]); } } Label0: if (!flag) { LabelToken labelToken2 = labelToken; Token token7 = labelToken2; if (labelToken2 == null) { token7 = switchToken; } IScriptExtent scriptExtent1 = Parser.ExtentOf(token7, token6); if (labelToken != null) { labelText = labelToken.LabelText; } else { labelText = null; } return new SwitchStatementAst(scriptExtent1, labelText, pipelineAst, switchFlag, tuples, statementBlockAst); } else { IScriptExtent scriptExtent2 = Parser.ExtentOf(scriptExtent, extent); Token token8 = switchToken; Dictionary<string, Tuple<Token, Ast>> strs5 = strs; if (flag2) { object[] objArray = new object[1]; objArray[0] = pipelineAst; nestedErrorAsts = Parser.GetNestedErrorAsts(objArray); } else { nestedErrorAsts = null; } object[] objArray1 = new object[1]; objArray1[0] = asts; return new ErrorStatementAst(scriptExtent2, token8, strs5, nestedErrorAsts, Parser.GetNestedErrorAsts(objArray1)); } }
public object VisitPipeline(PipelineAst pipelineAst) { var expr = pipelineAst.GetPureExpression(); if (expr != null) { return expr.Accept(this); } throw PSTraceSource.NewArgumentException("ast"); }
public object VisitPipeline(PipelineAst pipelineAst) { var expr = pipelineAst.GetPureExpression(); return(expr != null && (bool)expr.Accept(this)); }
public object VisitPipeline(PipelineAst pipelineAst) { CheckIsConstant(pipelineAst, "Caller to verify ast is constant"); return(pipelineAst.GetPureExpression().Accept(this)); }
/// <summary/> public virtual AstVisitAction VisitPipeline(PipelineAst pipelineAst) => DefaultVisit(pipelineAst);
internal override IEnumerable <PSTypeName> GetInferredType(CompletionContext context) { if (this.VariablePath.IsVariable) { Ast parent = this.Parent; if (this.VariablePath.IsUnqualified && (this.VariablePath.UserPath.Equals("_", StringComparison.Ordinal) || this.VariablePath.UserPath.Equals("PSItem", StringComparison.OrdinalIgnoreCase))) { while (parent != null) { if (parent is ScriptBlockExpressionAst) { break; } parent = parent.Parent; } if (parent != null) { if ((parent.Parent is CommandExpressionAst) && (parent.Parent.Parent is PipelineAst)) { if (parent.Parent.Parent.Parent is HashtableAst) { parent = parent.Parent.Parent.Parent; } else if ((parent.Parent.Parent.Parent is ArrayLiteralAst) && (parent.Parent.Parent.Parent.Parent is HashtableAst)) { parent = parent.Parent.Parent.Parent.Parent; } } if (parent.Parent is CommandParameterAst) { parent = parent.Parent; } CommandAst iteratorVariable1 = parent.Parent as CommandAst; if (iteratorVariable1 != null) { PipelineAst iteratorVariable2 = (PipelineAst)iteratorVariable1.Parent; int iteratorVariable3 = iteratorVariable2.PipelineElements.IndexOf(iteratorVariable1) - 1; if (iteratorVariable3 >= 0) { foreach (PSTypeName iteratorVariable4 in iteratorVariable2.PipelineElements[0].GetInferredType(context)) { if (iteratorVariable4.Type != null) { if (iteratorVariable4.Type.IsArray) { yield return(new PSTypeName(iteratorVariable4.Type.GetElementType())); continue; } if (typeof(IEnumerable).IsAssignableFrom(iteratorVariable4.Type)) { IEnumerable <Type> iteratorVariable5 = from t in iteratorVariable4.Type.GetInterfaces() where t.IsGenericType && t.GetGenericTypeDefinition().Equals(typeof(IEnumerable <>)) select t; foreach (Type iteratorVariable6 in iteratorVariable5) { yield return(new PSTypeName(iteratorVariable6.GetGenericArguments()[0])); } continue; } } yield return(iteratorVariable4); } } goto Label_0833; } } } if (this.VariablePath.IsUnqualified) { for (int i = 0; i < SpecialVariables.AutomaticVariables.Length; i++) { if (this.VariablePath.UserPath.Equals(SpecialVariables.AutomaticVariables[i], StringComparison.OrdinalIgnoreCase)) { Type type = SpecialVariables.AutomaticVariableTypes[i]; if (!type.Equals(typeof(object))) { yield return(new PSTypeName(type)); break; } break; } } } while (parent.Parent != null) { parent = parent.Parent; } if (parent.Parent is FunctionDefinitionAst) { parent = parent.Parent; } IEnumerable <Ast> source = AstSearcher.FindAll(parent, ast => (((ast is ParameterAst) || (ast is AssignmentStatementAst)) || (ast is ForEachStatementAst)) && this.AstAssignsToSameVariable(ast), true); ParameterAst iteratorVariable10 = source.OfType <ParameterAst>().FirstOrDefault <ParameterAst>(); if (iteratorVariable10 != null) { PSTypeName[] iteratorVariable11 = iteratorVariable10.GetInferredType(context).ToArray <PSTypeName>(); if (iteratorVariable11.Length > 0) { foreach (PSTypeName iteratorVariable12 in iteratorVariable11) { yield return(iteratorVariable12); } goto Label_0833; } } AssignmentStatementAst[] iteratorVariable13 = source.OfType <AssignmentStatementAst>().ToArray <AssignmentStatementAst>(); foreach (AssignmentStatementAst iteratorVariable14 in iteratorVariable13) { ConvertExpressionAst left = iteratorVariable14.Left as ConvertExpressionAst; if ((left != null) && (left.StaticType != null)) { yield return(new PSTypeName(left.StaticType)); goto Label_0833; } } ForEachStatementAst iteratorVariable16 = source.OfType <ForEachStatementAst>().FirstOrDefault <ForEachStatementAst>(); if (iteratorVariable16 != null) { foreach (PSTypeName iteratorVariable17 in iteratorVariable16.Condition.GetInferredType(context)) { yield return(iteratorVariable17); } } else { int startOffset = this.Extent.StartOffset; int iteratorVariable19 = 0x7fffffff; AssignmentStatementAst iteratorVariable20 = null; foreach (AssignmentStatementAst ast in iteratorVariable13) { int endOffset = ast.Extent.EndOffset; if ((endOffset < startOffset) && ((startOffset - endOffset) < iteratorVariable19)) { iteratorVariable19 = startOffset - endOffset; iteratorVariable20 = ast; } } if (iteratorVariable20 != null) { foreach (PSTypeName iteratorVariable21 in iteratorVariable20.Right.GetInferredType(context)) { yield return(iteratorVariable21); } } } } Label_0833: yield break; }
public override AstVisitAction VisitPipeline(PipelineAst ast) { return(Check(ast)); }
public object VisitPipeline(PipelineAst pipelineAst) { CheckIsConstant(pipelineAst, "Caller to verify ast is constant"); return pipelineAst.GetPureExpression().Accept(this); }
public object VisitPipeline(PipelineAst pipelineAst) { List<ParameterExpression> list = new List<ParameterExpression>(); List<Expression> list2 = new List<Expression>(); if (!(pipelineAst.Parent is AssignmentStatementAst) && !(pipelineAst.Parent is ParenExpressionAst)) { list2.Add(this.UpdatePosition(pipelineAst)); } ReadOnlyCollection<CommandBaseAst> pipelineElements = pipelineAst.PipelineElements; CommandExpressionAst commandExpr = pipelineElements[0] as CommandExpressionAst; if ((commandExpr != null) && (pipelineElements.Count == 1)) { if (commandExpr.Redirections.Count > 0) { return this.GetRedirectedExpression(commandExpr, false); } list2.Add(this.Compile(commandExpr)); } else { Expression redirectedExpression; int num; int count; Expression nullCommandRedirections; if (commandExpr != null) { if (commandExpr.Redirections.Count > 0) { redirectedExpression = this.GetRedirectedExpression(commandExpr, true); } else { redirectedExpression = this.GetRangeEnumerator(commandExpr.Expression) ?? this.Compile(commandExpr.Expression); } num = 1; count = pipelineElements.Count - 1; } else { redirectedExpression = ExpressionCache.AutomationNullConstant; num = 0; count = pipelineElements.Count; } Expression[] initializers = new Expression[count]; CommandBaseAst[] astArray = new CommandBaseAst[count]; object[] array = new object[count]; for (int i = 0; num < pipelineElements.Count; i++) { CommandBaseAst ast = pipelineElements[num]; initializers[i] = this.Compile(ast); array[i] = this.GetCommandRedirections(ast); astArray[i] = ast; num++; } if ((from r in array where r is Expression select r).Any<object>()) { nullCommandRedirections = Expression.NewArrayInit(typeof(CommandRedirection[]), (IEnumerable<Expression>) (from r in array select (r as Expression) ?? Expression.Constant(r, typeof(CommandRedirection[])))); } else if ((from r in array where r != null select r).Any<object>()) { nullCommandRedirections = Expression.Constant(Array.ConvertAll<object, CommandRedirection[]>(array, r => r as CommandRedirection[])); } else { nullCommandRedirections = ExpressionCache.NullCommandRedirections; } if (commandExpr != null) { ParameterExpression expression3 = Expression.Variable(redirectedExpression.Type); list.Add(expression3); list2.Add(Expression.Assign(expression3, redirectedExpression)); redirectedExpression = expression3; } Expression item = Expression.Call(CachedReflectionInfo.PipelineOps_InvokePipeline, new Expression[] { redirectedExpression.Cast(typeof(object)), (commandExpr != null) ? ExpressionCache.FalseConstant : ExpressionCache.TrueConstant, Expression.NewArrayInit(typeof(CommandParameterInternal[]), initializers), Expression.Constant(astArray), nullCommandRedirections, _functionContext }); list2.Add(item); } return Expression.Block((IEnumerable<ParameterExpression>) list, (IEnumerable<Expression>) list2); }
public object VisitPipeline(PipelineAst pipelineAst) { var expr = pipelineAst.GetPureExpression(); return expr != null && (bool)expr.Accept(this); }
private StatementAst SwitchStatementRule(LabelToken labelToken, Token switchToken) { //G switch-statement: //G 'switch' new-lines:opt switch-parameters:opt switch-condition switch-body //G switch-parameters: //G switch-parameter //G switch-parameters switch-parameter //G switch-parameter: //G '-regex' //G '-wildcard' //G '-exact' //G '-casesensitive' //G '-parallel' //G switch-condition: //G '(' new-lines:opt pipeline new-lines:opt ')' //G -file new-lines:opt switch-filename //G switch-filename: //G command-argument //G primary-expression //G switch-body: //G new-lines:opt '{' new-lines:opt switch-clauses '}' //G switch-clauses: //G switch-clause //G switch-clauses switch-clause //G switch-clause: //G switch-clause-condition statement-block statement-terminators:opt //G switch-clause-condition: //G command-argument //G primary-expression IScriptExtent startExtent = (labelToken ?? switchToken).Extent; IScriptExtent endErrorStatement = startExtent; bool isError = false; bool isIncompleteError = false; SkipNewlines(); bool needErrorCondition = false; // Only used to track if we need to include (condition) ast for the error statement. PipelineBaseAst condition = null; Dictionary<string, Tuple<Token, Ast>> specifiedFlags = null; // Only used to track all flags specified for the error ast Token switchParameterToken = PeekToken(); SwitchFlags flags = SwitchFlags.None; while (switchParameterToken.Kind == TokenKind.Parameter) { SkipToken(); endErrorStatement = switchParameterToken.Extent; specifiedFlags = specifiedFlags ?? new Dictionary<string, Tuple<Token, Ast>>(); if (IsSpecificParameter(switchParameterToken, "regex")) { flags |= SwitchFlags.Regex; flags &= ~SwitchFlags.Wildcard; if (!specifiedFlags.ContainsKey("regex")) { specifiedFlags.Add("regex", new Tuple<Token, Ast>(switchParameterToken, null)); } } else if (IsSpecificParameter(switchParameterToken, "wildcard")) { flags |= SwitchFlags.Wildcard; flags &= ~SwitchFlags.Regex; if (!specifiedFlags.ContainsKey("wildcard")) { specifiedFlags.Add("wildcard", new Tuple<Token, Ast>(switchParameterToken, null)); } } else if (IsSpecificParameter(switchParameterToken, "exact")) { flags &= ~SwitchFlags.Regex; flags &= ~SwitchFlags.Wildcard; if (!specifiedFlags.ContainsKey("exact")) { specifiedFlags.Add("exact", new Tuple<Token, Ast>(switchParameterToken, null)); } } else if (IsSpecificParameter(switchParameterToken, "casesensitive")) { flags |= SwitchFlags.CaseSensitive; if (!specifiedFlags.ContainsKey("casesensitive")) { specifiedFlags.Add("casesensitive", new Tuple<Token, Ast>(switchParameterToken, null)); } } else if (IsSpecificParameter(switchParameterToken, "parallel")) { flags |= SwitchFlags.Parallel; if (!specifiedFlags.ContainsKey("parallel")) { specifiedFlags.Add("parallel", new Tuple<Token, Ast>(switchParameterToken, null)); } } else if (IsSpecificParameter(switchParameterToken, "file")) { flags |= SwitchFlags.File; SkipNewlines(); ExpressionAst fileNameExpr = GetSingleCommandArgument(CommandArgumentContext.FileName); if (fileNameExpr == null) { // ErrorRecovery: pretend we saw the filename and continue. isError = true; isIncompleteError = ReportIncompleteInput(After(switchParameterToken), () => ParserStrings.MissingFilenameOption); if (!specifiedFlags.ContainsKey("file")) { specifiedFlags.Add("file", new Tuple<Token, Ast>(switchParameterToken, null)); } } else { endErrorStatement = fileNameExpr.Extent; condition = new PipelineAst(fileNameExpr.Extent, new CommandExpressionAst(fileNameExpr.Extent, fileNameExpr, null)); if (!specifiedFlags.ContainsKey("file")) { specifiedFlags.Add("file", new Tuple<Token, Ast>(switchParameterToken, condition)); } } } else { // ErrorRecovery: just ignore the token, continue parsing. isError = true; ReportError(switchParameterToken.Extent, () => ParserStrings.InvalidSwitchFlag, ((ParameterToken)switchParameterToken).ParameterName); } switchParameterToken = PeekToken(); } if (switchParameterToken.Kind == TokenKind.Minus) { specifiedFlags = specifiedFlags ?? new Dictionary<string, Tuple<Token, Ast>>(); specifiedFlags.Add(VERBATIM_ARGUMENT, new Tuple<Token, Ast>(switchParameterToken, null)); } Token lParen = PeekToken(); if (lParen.Kind == TokenKind.LParen) { endErrorStatement = lParen.Extent; SkipToken(); if ((flags & SwitchFlags.File) == SwitchFlags.File) { // ErrorRecovery: nothing special this is a semantic error. isError = true; ReportError(lParen.Extent, () => ParserStrings.PipelineValueRequired); } needErrorCondition = true; // need to add condition ast to the error statement if the parsing fails SkipNewlines(); condition = PipelineRule(); if (condition == null) { // ErrorRecovery: pretend we saw the condition and keep parsing. isError = true; isIncompleteError = ReportIncompleteInput(After(lParen), () => ParserStrings.PipelineValueRequired); } else { endErrorStatement = condition.Extent; } SkipNewlines(); Token rParen = NextToken(); if (rParen.Kind != TokenKind.RParen) { // ErrorRecovery: Try to parse the switch body, if we don't find a body, then bail. UngetToken(rParen); if (!isIncompleteError) { isError = true; isIncompleteError = ReportIncompleteInput(After(endErrorStatement), () => ParserStrings.MissingEndParenthesisInSwitchStatement); } } else { endErrorStatement = rParen.Extent; } } else if (condition == null) { if ((flags & SwitchFlags.File) == 0) { isError = true; isIncompleteError = ReportIncompleteInput(After(endErrorStatement), () => ParserStrings.PipelineValueRequired); } else { Diagnostics.Assert(isError, "An error should already have been issued"); } } SkipNewlines(); Token lCurly = NextToken(); StatementBlockAst @default = null; List<SwitchClause> clauses = new List<SwitchClause>(); List<Ast> errorAsts = new List<Ast>(); // in case there is an error, we want the asts parsed up to the error. Token rCurly = null; if (lCurly.Kind != TokenKind.LCurly) { // ErrorRecovery: Assume we don't have any switch body to parse. UngetToken(lCurly); if (!isIncompleteError) { isError = true; ReportIncompleteInput(After(endErrorStatement), () => ParserStrings.MissingCurlyBraceInSwitchStatement); } } else { endErrorStatement = lCurly.Extent; SkipNewlines(); while (true) { ExpressionAst clauseCondition = GetSingleCommandArgument(CommandArgumentContext.SwitchCondition); if (clauseCondition == null) { // ErrorRecovery: if we don't have anything that looks like a condition, we won't // find a body (because a body is just a script block, which works as a condition.) // So don't look for a body, hope we find the '}' next. isError = true; ReportIncompleteInput(After(endErrorStatement), () => ParserStrings.MissingSwitchConditionExpression); // Consume a closing curly, if there is one, to avoid an extra error if (PeekToken().Kind == TokenKind.RCurly) { SkipToken(); } break; } errorAsts.Add(clauseCondition); endErrorStatement = clauseCondition.Extent; StatementBlockAst clauseBody = StatementBlockRule(); if (clauseBody == null) { // ErrorRecovery: We might find another condition/body pair, so keep going. isError = true; isIncompleteError = ReportIncompleteInput(After(endErrorStatement), () => ParserStrings.MissingSwitchStatementClause); } else { errorAsts.Add(clauseBody); endErrorStatement = clauseBody.Extent; var clauseConditionString = clauseCondition as StringConstantExpressionAst; if (clauseConditionString != null && clauseConditionString.StringConstantType == StringConstantType.BareWord && clauseConditionString.Value.Equals("default", StringComparison.OrdinalIgnoreCase)) { if (@default != null) { // ErrorRecovery: just report the error and continue, forget the previous default clause. isError = true; ReportError(clauseCondition.Extent, () => ParserStrings.MultipleSwitchDefaultClauses); } @default = clauseBody; } else { clauses.Add(new SwitchClause(clauseCondition, clauseBody)); } } SkipNewlinesAndSemicolons(); Token token = PeekToken(); if (token.Kind == TokenKind.RCurly) { rCurly = token; SkipToken(); break; } if (token.Kind == TokenKind.EndOfInput) { if (!isIncompleteError) { isError = true; ReportIncompleteInput(lCurly.Extent, token.Extent, () => ParserStrings.MissingEndCurlyBrace); } break; } } } if (isError) { return new ErrorStatementAst(ExtentOf(startExtent, endErrorStatement), switchToken, specifiedFlags, needErrorCondition ? GetNestedErrorAsts(condition) : null, GetNestedErrorAsts(errorAsts)); } return new SwitchStatementAst(ExtentOf(labelToken ?? switchToken, rCurly), labelToken != null ? labelToken.LabelText : null, condition, flags, clauses, @default); }
private void ConvertPipeline(PipelineAst pipelineAst) { foreach (CommandBaseAst ast in pipelineAst.PipelineElements) { this.ConvertCommand((CommandAst) ast); } }
/// <summary/> public virtual AstVisitAction VisitPipeline(PipelineAst pipelineAst) { return(AstVisitAction.Continue); }
public override AstVisitAction VisitPipeline(PipelineAst pipelineAst) { return AstVisitAction.Continue; }
public override AstVisitAction VisitPipeline(PipelineAst pipelineAst) { // A pipeline is accepted if every command in the pipeline is accepted. return AstVisitAction.Continue; }
public override AstVisitAction VisitPipeline(PipelineAst pipelineAst) { // shouldn't happen, but anyway if (!pipelineAst.PipelineElements.Any()) { return AstVisitAction.SkipChildren; } // Pipeline uses global execution context, so we should set its WriteSideEffects flag, and restore it after. // TODO: I'm not very sure about that changing context and WriteSideEffectsToPipeline stuff var pipeLineContext = _context.CurrentRunspace.ExecutionContext; bool writeSideEffects = pipeLineContext.WriteSideEffectsToPipeline; try { pipeLineContext.WriteSideEffectsToPipeline = _writeSideEffectsToPipeline; var pipeline = _context.CurrentRunspace.CreateNestedPipeline(); int startAt = 0; // set to 1 if first element is an expression int pipelineCommandCount = pipelineAst.PipelineElements.Count; // first element of pipeline can be an expression that needs to be evaluated var expression = pipelineAst.PipelineElements[0] as CommandExpressionAst; if (expression != null) { // evaluate it and get results var value = EvaluateAst(expression.Expression, _writeSideEffectsToPipeline); // if we only have that one expression and no commands, write expression to output and return if (pipelineCommandCount == 1) { if (value != null) { _pipelineCommandRuntime.WriteObject(value, true); } return AstVisitAction.SkipChildren; } // otherwise write value to input of pipeline to be processed if (value != null) { pipeline.Input.Write(value, true); } startAt = 1; } else // if there was no expression we take the input of the context's input stream { foreach (var input in _context.InputStream.Read()) { pipeline.Input.Write(input); } } // all other elements *need* to be commands (same in PS). Make that sure and add them to the pipeline for (int curCommand = startAt; curCommand < pipelineCommandCount; curCommand++) { var commandAst = pipelineAst.PipelineElements[curCommand] as CommandAst; if (commandAst == null) { throw new NotSupportedException("Invalid command in pipeline." + " Only the first element of a pipeline can be an expression."); } var command = GetCommand(commandAst); commandAst.CommandElements // the first CommandElements is the command itself. The rest are parameters/arguments .Skip(1) .Select(ConvertCommandElementToCommandParameter) .ForEach(command.Parameters.Add); pipeline.Commands.Add(command); } // now execute the pipeline _context.PushPipeline(pipeline); try { var results = pipeline.Invoke(); // read output and error and write them as results of the current commandRuntime foreach (var curResult in results) { _pipelineCommandRuntime.WriteObject(curResult); } var errors = pipeline.Error.NonBlockingRead(); foreach (var curError in errors) { _pipelineCommandRuntime.ErrorStream.Write(curError); } } finally { _context.PopPipeline(); } } finally { pipeLineContext.WriteSideEffectsToPipeline = writeSideEffects; } return AstVisitAction.SkipChildren; }
/// <summary/> public virtual object VisitPipeline(PipelineAst pipelineAst) { return null; }
/// <summary> /// Visit pipeline /// </summary> /// <param name="pipelineAst"></param> /// <returns></returns> public object VisitPipeline(PipelineAst pipelineAst) { if (pipelineAst == null) return null; bool invokesCommand = false; foreach (var command in pipelineAst.PipelineElements) { command.Visit(this.Decorator); if (command is CommandAst) { invokesCommand = true; } foreach (var redir in command.Redirections) { redir.Visit(this.Decorator); } } // Because non-local gotos are supported, we must model them in the flow graph. We can't detect them // in general, so we must be pessimistic and assume any command invocation could result in non-local // break or continue, so add the appropriate edges to our graph. These edges occur after visiting // the command elements because command arguments could create new blocks, and we won't have executed // the command yet. if (invokesCommand && _loopTargets.Any()) { foreach (var loopTarget in _loopTargets) { _currentBlock.FlowsTo(loopTarget.BreakTarget); _currentBlock.FlowsTo(loopTarget.ContinueTarget); } // The rest of the block is potentially unreachable, so split the current block. var newBlock = new Block(); _currentBlock.FlowsTo(newBlock); _currentBlock = newBlock; } return null; }
public virtual AstVisitAction VisitPipeline(PipelineAst pipelineAst) { return AstVisitAction.Continue; }
public override AstVisitAction VisitPipeline(PipelineAst pipelineAst) { // shouldn't happen, but anyway if (!pipelineAst.PipelineElements.Any()) { return AstVisitAction.SkipChildren; } // Pipeline uses global execution context, so we should set its WriteSideEffects flag, and restore it after. // TODO: I'm not very sure about that changing context and WriteSideEffectsToPipeline stuff var pipeLineContext = ExecutionContext.CurrentRunspace.ExecutionContext; bool writeSideEffects = pipeLineContext.WriteSideEffectsToPipeline; try { pipeLineContext.WriteSideEffectsToPipeline = _writeSideEffectsToPipeline; var pipeline = ExecutionContext.CurrentRunspace.CreateNestedPipeline(); int startAt = 0; // set to 1 if first element is an expression int pipelineCommandCount = pipelineAst.PipelineElements.Count; // first element of pipeline can be an expression that needs to be evaluated var expression = pipelineAst.PipelineElements[0] as CommandExpressionAst; if (expression != null) { // evaluate it and get results var subVisitor = this.CloneSub(_writeSideEffectsToPipeline); expression.Expression.Visit(subVisitor); var results = subVisitor._pipelineCommandRuntime.OutputStream.Read(); // if we only have that one expression and no commands, write expression to output and return if (pipelineCommandCount == 1) { _pipelineCommandRuntime.WriteObject(results, true); VisitRedirections(expression); return AstVisitAction.SkipChildren; } // otherwise write value to input of pipeline to be processed if (results.Count == 1) { // "unroll" an input array: write all enumerated elements seperately to the pipeline pipeline.Input.Write(results[0], true); } else { pipeline.Input.Write(results, true); } startAt = 1; } else // if there was no expression we take the input of the context's input stream { foreach (var input in ExecutionContext.InputStream.Read()) { pipeline.Input.Write(input); } } // all other elements *need* to be commands (same in PS). Make that sure and add them to the pipeline for (int curCommand = startAt; curCommand < pipelineCommandCount; curCommand++) { var commandAst = pipelineAst.PipelineElements[curCommand] as CommandAst; if (commandAst == null) { throw new NotSupportedException("Invalid command in pipeline." + " Only the first element of a pipeline can be an expression."); } var command = GetCommand(commandAst); commandAst.CommandElements // the first CommandElements is the command itself. The rest are parameters/arguments .Skip(1) .Select(ConvertCommandElementToCommandParameter) .ForEach(command.Parameters.Add); command.RedirectionVisitor = new RedirectionVisitor(this, commandAst.Redirections); pipeline.Commands.Add(command); } // now execute the pipeline ExecutionContext.PushPipeline(pipeline); // rerouting the output and error stream would be easier, but Pipeline doesn't // have an interface for this. So let's catch the exception for now, read the streams // and rethrow it afterwards Exception exception = null; Collection<PSObject> pipeResults = null; try { pipeResults = pipeline.Invoke(); } catch (Exception e) { exception = e; pipeResults = pipeline.Output.NonBlockingRead(); } // read output and error and write them as results of the current commandRuntime foreach (var curResult in pipeResults) { _pipelineCommandRuntime.WriteObject(curResult); } var errors = pipeline.Error.NonBlockingRead(); foreach (var curError in errors) { _pipelineCommandRuntime.ErrorStream.Write(curError); } ExecutionContext.PopPipeline(); if (exception != null) { throw exception; } } finally { pipeLineContext.WriteSideEffectsToPipeline = writeSideEffects; } return AstVisitAction.SkipChildren; }
public object VisitPipeline(PipelineAst pipelineAst) { return pipelineAst.GetPureExpression().Accept(this); }
private void ConvertPipeline(PipelineAst pipelineAst, bool isTrustedInput) { foreach (var command in pipelineAst.PipelineElements) { ConvertCommand((CommandAst)command, isTrustedInput); } }
public object VisitPipeline(PipelineAst pipelineAst) { ExpressionAst pureExpression = pipelineAst.GetPureExpression(); return((pureExpression == null) ? ((object)false) : ((object)((bool)pureExpression.Accept(this)))); }
public override AstVisitAction VisitPipeline(PipelineAst pipelineAst) { // TODO: rewrite this - it should expand the commands in the original pipe PipelineCommandRuntime subRuntime = null; foreach (var pipelineElement in pipelineAst.PipelineElements) { ExecutionContext subContext = this._context.CreateNestedContext(); if (subRuntime == null) { subContext.inputStreamReader = this._context.inputStreamReader; } else { subContext.inputStreamReader = new PSObjectPipelineReader(subRuntime.outputResults); } subRuntime = new PipelineCommandRuntime(this._pipelineCommandRuntime.pipelineProcessor); subContext.inputStreamReader = subContext.inputStreamReader; pipelineElement.Visit(new ExecutionVisitor(subContext, subRuntime, this._writeSideEffectsToPipeline)); } this._pipelineCommandRuntime.WriteObject(subRuntime.outputResults.Read(), true); return AstVisitAction.SkipChildren; }
public override AstVisitAction VisitPipeline(PipelineAst ast) { return this.Check(ast); }
public object VisitPipeline(PipelineAst pipelineAst) { ExpressionAst pureExpression = pipelineAst.GetPureExpression(); return ((pureExpression == null) ? ((object) false) : ((object) ((bool) pureExpression.Accept(this)))); }
public object VisitPipeline(PipelineAst pipelineAst) { foreach (var element in pipelineAst.PipelineElements) { return Visit(element); } return new CodeExpression(); }