public string GetCommandName() { StringConstantExpressionAst ast = this.CommandElements[0] as StringConstantExpressionAst; if (ast == null) { return(null); } return(ast.Value); }
public Expression SetValue(Compiler compiler, Expression rhs) { StringConstantExpressionAst member = this.MemberExpression.Member as StringConstantExpressionAst; if (member != null) { return(Expression.Dynamic(PSSetMemberBinder.Get(member.Value, this.MemberExpression.Static), typeof(object), this.CachedTarget ?? this.GetTargetExpr(compiler), rhs)); } return(Expression.Dynamic(PSSetDynamicMemberBinder.Get(this.MemberExpression.Static), typeof(object), this.CachedTarget ?? this.GetTargetExpr(compiler), this.CachedPropertyExpr ?? this.GetPropertyExpr(compiler), rhs)); }
public Expression SetValue(Compiler compiler, Expression rhs) { PSMethodInvocationConstraints invokeMemberConstraints = Compiler.GetInvokeMemberConstraints(this.InvokeMemberExpressionAst); StringConstantExpressionAst member = this.InvokeMemberExpressionAst.Member as StringConstantExpressionAst; Expression targetExpr = this.GetTargetExpr(compiler); IEnumerable <Expression> argumentExprs = this.GetArgumentExprs(compiler); if (member == null) { throw new NotImplementedException("invoke method dynamic name"); } return(Compiler.InvokeMember(member.Value, invokeMemberConstraints, targetExpr, argumentExprs.Append <Expression>(rhs), false, true)); }
public override AstVisitAction VisitCommand(CommandAst commandAst) { StringConstantExpressionAst ast = commandAst.CommandElements[0] as StringConstantExpressionAst; if ((ast != null) && hashOfPessimizingCmdlets.Contains(ast.Value)) { this._disableOptimizations = true; } if (commandAst.InvocationOperator == TokenKind.Dot) { this._disableOptimizations = true; } return(AstVisitAction.Continue); }
private static string GetLabel(ExpressionAst expr) { if (expr == null) { return(""); } StringConstantExpressionAst ast = expr as StringConstantExpressionAst; if (ast == null) { return(null); } return(ast.Value); }
public override object VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { if (stringConstantExpressionAst == ast) { var newAst = new StringConstantExpressionAst(stringConstantExpressionAst.Extent, code, stringConstantExpressionAst.StringConstantType); rootAst.ModifiedAsts.Add(newAst); return newAst; } else return base.VisitStringConstantExpression(stringConstantExpressionAst); }
public override object VisitInvokeMemberExpression(InvokeMemberExpressionAst invokeMemberExpressionAst) { var newExpression = VisitElement(invokeMemberExpressionAst.Expression); CommandElementAst newMethod; if (invokeMemberExpressionAst == ast) { newMethod = new StringConstantExpressionAst(invokeMemberExpressionAst.Member.Extent, newMethodName, ((StringConstantExpressionAst) invokeMemberExpressionAst.Member).StringConstantType); rootAst.ModifiedAsts.Add(newMethod); } else { newMethod = VisitElement(invokeMemberExpressionAst.Member); } var newArguments = VisitElements(invokeMemberExpressionAst.Arguments); return new InvokeMemberExpressionAst(invokeMemberExpressionAst.Extent, newExpression, newMethod, newArguments, invokeMemberExpressionAst.Static); }
public Expression GetValue(Compiler compiler, List <Expression> exprs, List <ParameterExpression> temps) { Expression targetExpr = this.GetTargetExpr(compiler); ParameterExpression item = Expression.Parameter(targetExpr.Type); temps.Add(item); this.CachedTarget = item; exprs.Add(Expression.Assign(item, targetExpr)); StringConstantExpressionAst member = this.MemberExpression.Member as StringConstantExpressionAst; if (member != null) { return(Expression.Dynamic(PSGetMemberBinder.Get(member.Value, this.MemberExpression.Static), typeof(object), item)); } ParameterExpression expression4 = Expression.Parameter(this.GetPropertyExpr(compiler).Type); temps.Add(expression4); exprs.Add(Expression.Assign(expression4, compiler.Compile(this.MemberExpression.Member))); this.CachedPropertyExpr = expression4; return(Expression.Dynamic(PSGetDynamicMemberBinder.Get(this.MemberExpression.Static), typeof(object), item, expression4)); }
public Expression GetValue(Compiler compiler, List <Expression> exprs, List <ParameterExpression> temps) { PSMethodInvocationConstraints invokeMemberConstraints = Compiler.GetInvokeMemberConstraints(this.InvokeMemberExpressionAst); Expression targetExpr = this.GetTargetExpr(compiler); this._targetExprTemp = Expression.Variable(targetExpr.Type); exprs.Add(Expression.Assign(this._targetExprTemp, targetExpr)); IEnumerable <Expression> argumentExprs = this.GetArgumentExprs(compiler); this._argExprTemps = (from arg in argumentExprs select Expression.Variable(arg.Type)).ToArray <ParameterExpression>(); exprs.AddRange((IEnumerable <Expression>)argumentExprs.Zip <Expression, ParameterExpression, BinaryExpression>(this._argExprTemps, (arg, temp) => Expression.Assign(temp, arg))); temps.Add(this._targetExprTemp); temps.AddRange(this._argExprTemps); StringConstantExpressionAst member = this.InvokeMemberExpressionAst.Member as StringConstantExpressionAst; if (member == null) { throw new NotImplementedException("invoke method dynamic name"); } return(Compiler.InvokeMember(member.Value, invokeMemberConstraints, this._targetExprTemp, this._argExprTemps, false, false)); }
private void BreakOrContinue(ExpressionAst label, Func <LoopGotoTargets, Block> fieldSelector) { Func <LoopGotoTargets, Block> selector = null; Block next = null; if (label != null) { label.Accept(this); if (this._loopTargets.Any <LoopGotoTargets>()) { Func <LoopGotoTargets, bool> predicate = null; StringConstantExpressionAst labelStrAst = label as StringConstantExpressionAst; if (labelStrAst != null) { if (predicate == null) { predicate = t => t.Label.Equals(labelStrAst.Value, StringComparison.OrdinalIgnoreCase); } if (selector == null) { selector = t => fieldSelector(t); } next = this._loopTargets.Where <LoopGotoTargets>(predicate).Select <LoopGotoTargets, Block>(selector).LastOrDefault <Block>(); } } } else if (this._loopTargets.Count > 0) { next = fieldSelector(this._loopTargets.Last <LoopGotoTargets>()); } if (next != null) { this._currentBlock.FlowsTo(next); } this._currentBlock = new Block(); }
public virtual AstVisitAction VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { return AstVisitAction.Continue; }
public System.Object VisitStringConstantExpression(System.Management.Automation.Language.StringConstantExpressionAst stringConstantExpressionAst) { IScriptExtent mappedExtent = MapExtent(stringConstantExpressionAst.Extent); return(new StringConstantExpressionAst(mappedExtent, stringConstantExpressionAst.Value, stringConstantExpressionAst.StringConstantType)); }
/// <summary/> public virtual object VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { return _decorated.VisitStringConstantExpression(stringConstantExpressionAst); }
public override AstVisitAction VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { return AstVisitAction.Continue; }
public object VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { return Expression.Constant(stringConstantExpressionAst.Value); }
public CSharpPatcher(string code, StringConstantExpressionAst ast, PSScriptAst rootAst) : base(rootAst) { this.code = code; this.ast = ast; }
public object VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { return true; }
public CSharpClassAst(TypeDeclaration tree, StringConstantExpressionAst ast) { this.tree = tree; Ast = ast; }
public override AstVisitAction VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { // Constants are allowed. return AstVisitAction.Continue; }
public object VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { return stringConstantExpressionAst.Value; }
/// <summary/> public virtual AstVisitAction VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) => DefaultVisit(stringConstantExpressionAst);
internal CommandBaseAst CommandRule() { Token token; bool flag; bool flag2; IScriptExtent extent; bool flag3 = false; bool flag4 = false; RedirectionAst[] redirections = null; List<CommandElementAst> elements = new List<CommandElementAst>(); TokenizerMode mode = this._tokenizer.Mode; try { CommandArgumentContext commandNameAfterInvoationOperator; this.SetTokenizerMode(TokenizerMode.Command); Token first = this.NextToken(); token = first; extent = first.Extent; flag = false; flag2 = false; if (first.Kind == TokenKind.Dot) { flag = true; first = this.NextToken(); commandNameAfterInvoationOperator = CommandArgumentContext.CommandNameAfterInvocationOperator; } else if (first.Kind == TokenKind.Ampersand) { flag2 = true; first = this.NextToken(); commandNameAfterInvoationOperator = CommandArgumentContext.CommandNameAfterInvocationOperator; } else { commandNameAfterInvoationOperator = CommandArgumentContext.CommandName; } bool flag5 = true; while (flag5) { switch (first.Kind) { case TokenKind.Parameter: if (((commandNameAfterInvoationOperator & CommandArgumentContext.CommandName) != 0) || flag3) { extent = first.Extent; first.TokenFlags |= TokenFlags.CommandName; StringConstantExpressionAst item = new StringConstantExpressionAst(first.Extent, first.Text, StringConstantType.BareWord); elements.Add(item); } else { ExpressionAst commandArgument; IScriptExtent extent2; ParameterToken token3 = (ParameterToken) first; if (token3.UsedColon && (this.PeekToken().Kind != TokenKind.Comma)) { commandArgument = this.GetCommandArgument(CommandArgumentContext.CommandArgument, this.NextToken()); if (commandArgument == null) { extent2 = token3.Extent; this.ReportError(After(extent2), ParserStrings.ParameterRequiresArgument, new object[] { token3.Text }); } else { extent2 = ExtentOf(first, commandArgument); } } else { commandArgument = null; extent2 = first.Extent; } extent = extent2; CommandParameterAst ast3 = new CommandParameterAst(extent2, token3.ParameterName, commandArgument, first.Extent); elements.Add(ast3); } goto Label_0404; case TokenKind.NewLine: case TokenKind.RParen: case TokenKind.RCurly: case TokenKind.Semi: case TokenKind.AndAnd: case TokenKind.OrOr: case TokenKind.Pipe: case TokenKind.EndOfInput: { this.UngetToken(first); flag5 = false; continue; } case TokenKind.Ampersand: extent = first.Extent; this.ReportError(first.Extent, ParserStrings.MissingArgument, new object[0]); goto Label_0404; case TokenKind.Comma: extent = first.Extent; this.ReportError(first.Extent, ParserStrings.MissingArgument, new object[0]); this.SkipNewlines(); goto Label_0404; case TokenKind.MinusMinus: extent = first.Extent; elements.Add(flag3 ? ((CommandElementAst) new StringConstantExpressionAst(first.Extent, first.Text, StringConstantType.BareWord)) : ((CommandElementAst) new CommandParameterAst(first.Extent, "-", null, first.Extent))); flag3 = true; goto Label_0404; case TokenKind.Redirection: case TokenKind.RedirectInStd: if ((commandNameAfterInvoationOperator & CommandArgumentContext.CommandName) != 0) { break; } if (redirections == null) { redirections = new RedirectionAst[7]; } this.RedirectionRule((RedirectionToken) first, redirections, ref extent); goto Label_0404; default: { if ((first.Kind == TokenKind.InlineScript) && (commandNameAfterInvoationOperator == CommandArgumentContext.CommandName)) { flag5 = this.InlineScriptRule(first, elements); extent = elements.Last<CommandElementAst>().Extent; if (flag5) { goto Label_0404; } continue; } ExpressionAst ast4 = this.GetCommandArgument(commandNameAfterInvoationOperator, first); StringToken token4 = first as StringToken; if ((token4 != null) && string.Equals(token4.Value, "--%", StringComparison.OrdinalIgnoreCase)) { elements.Add(ast4); extent = ast4.Extent; StringToken verbatimCommandArgumentToken = this.GetVerbatimCommandArgumentToken(); if (verbatimCommandArgumentToken != null) { flag4 = true; flag5 = false; ast4 = new StringConstantExpressionAst(verbatimCommandArgumentToken.Extent, verbatimCommandArgumentToken.Value, StringConstantType.BareWord); elements.Add(ast4); extent = ast4.Extent; } } else { extent = ast4.Extent; elements.Add(ast4); } goto Label_0404; } } extent = first.Extent; elements.Add(new StringConstantExpressionAst(first.Extent, first.Text, StringConstantType.BareWord)); Label_0404: if (!flag4) { commandNameAfterInvoationOperator = CommandArgumentContext.CommandArgument; first = this.NextToken(); } } } finally { this.SetTokenizerMode(mode); } if (elements.Count == 0) { if (flag || flag2) { IScriptExtent extent3 = token.Extent; this.ReportError(extent3, ParserStrings.MissingExpression, new object[] { token.Text }); return new CommandExpressionAst(extent3, new ErrorExpressionAst(extent3, null), null); } return null; } return new CommandAst(ExtentOf(token, extent), elements, (flag || flag2) ? token.Kind : TokenKind.Unknown, (redirections != null) ? redirections.Where<RedirectionAst>(r => r != null) : null); }
private ExpressionAst PrimaryExpressionRule(bool withMemberAccess) { ExpressionAst constantExpressionAst; Token token = this.NextToken(); TokenKind kind = token.Kind; if (kind == TokenKind.Variable || kind == TokenKind.SplattedVariable) { constantExpressionAst = this.CheckUsingVariable((VariableToken)token, withMemberAccess); if (withMemberAccess) { return this.CheckPostPrimaryExpressionOperators(this.NextMemberAccessToken(true), constantExpressionAst); } else { return constantExpressionAst; } this.UngetToken(token); return null; } else if (kind == TokenKind.Parameter) { this.UngetToken(token); return null; } else if (kind == TokenKind.Number) { constantExpressionAst = new ConstantExpressionAst((NumberToken)token); if (withMemberAccess) { return this.CheckPostPrimaryExpressionOperators(this.NextMemberAccessToken(true), constantExpressionAst); } else { return constantExpressionAst; } this.UngetToken(token); return null; } if (kind == TokenKind.StringLiteral || kind == TokenKind.HereStringLiteral) { constantExpressionAst = new StringConstantExpressionAst((StringToken)token); } else if (kind == TokenKind.StringExpandable || kind == TokenKind.HereStringExpandable) { constantExpressionAst = this.ExpandableStringRule((StringExpandableToken)token); } else if (kind == TokenKind.LParen) { constantExpressionAst = this.ParenthesizedExpressionRule(token); } else if (kind == TokenKind.RParen || kind == TokenKind.RCurly || kind == TokenKind.LBracket || kind == TokenKind.RBracket) { this.UngetToken(token); return null; } else if (kind == TokenKind.LCurly) { constantExpressionAst = this.ScriptBlockExpressionRule(token); } else if (kind == TokenKind.AtParen || kind == TokenKind.DollarParen) { constantExpressionAst = this.SubExpressionRule(token); } else if (kind == TokenKind.AtCurly) { constantExpressionAst = this.HashExpressionRule(token); } else { this.UngetToken(token); return null; } if (withMemberAccess) { return this.CheckPostPrimaryExpressionOperators(this.NextMemberAccessToken(true), constantExpressionAst); } else { return constantExpressionAst; } this.UngetToken(token); return null; }
private bool InlineScriptRule(Token inlineScriptToken, List<CommandElementAst> elements) { StringConstantExpressionAst stringConstantExpressionAst = new StringConstantExpressionAst(inlineScriptToken.Extent, inlineScriptToken.Text, StringConstantType.BareWord); Token tokenFlags = inlineScriptToken; tokenFlags.TokenFlags = tokenFlags.TokenFlags | TokenFlags.CommandName; elements.Add(stringConstantExpressionAst); this.SkipNewlines(); Token token = this.NextToken(); if (token.Kind == TokenKind.LCurly) { ExpressionAst expressionAst = this.ScriptBlockExpressionRule(token); elements.Add(expressionAst); return true; } else { this.UngetToken(token); object[] text = new object[1]; text[0] = inlineScriptToken.Text; this.ReportIncompleteInput(Parser.After(inlineScriptToken), ParserStrings.MissingStatementAfterKeyword, text); return false; } }
/// <summary/> public virtual object VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { return(null); }
private AssignmentStatementAst GetAssignmentStatementAst(ExpressionAst leftExpressionAst, TokenKind tokenKind) { var expressionAst = new StringConstantExpressionAst(extent, "tmp", StringConstantType.BareWord); var commandExpressionAst = new CommandExpressionAst(extent, expressionAst, redirections); return new AssignmentStatementAst(extent, leftExpressionAst, tokenKind, commandExpressionAst, extent); }
private ExpressionAst GetCommandArgument(CommandArgumentContext context, Token token) { ExpressionAst ast; List<ExpressionAst> source = null; Token token2 = null; bool flag = false; Label_0006: switch (token.Kind) { case TokenKind.Variable: case TokenKind.SplattedVariable: case TokenKind.Number: case TokenKind.StringLiteral: case TokenKind.StringExpandable: case TokenKind.HereStringLiteral: case TokenKind.HereStringExpandable: case TokenKind.LParen: case TokenKind.LCurly: case TokenKind.AtParen: case TokenKind.AtCurly: case TokenKind.DollarParen: this.UngetToken(token); ast = this.PrimaryExpressionRule(true); break; case TokenKind.Generic: { if ((context & CommandArgumentContext.CommandName) != 0) { token.TokenFlags |= TokenFlags.CommandName; } StringToken token3 = (StringToken)token; StringExpandableToken expandableStringToken = token3 as StringExpandableToken; if ((expandableStringToken != null) && (context != CommandArgumentContext.CommandName)) { List<ExpressionAst> nestedExpressions = this.ParseNestedExpressions(expandableStringToken); ast = new ExpandableStringExpressionAst(expandableStringToken, expandableStringToken.Value, expandableStringToken.FormatString, nestedExpressions); } else { ast = new StringConstantExpressionAst(token3.Extent, token3.Value, StringConstantType.BareWord); if (string.Equals(token3.Value, "--%", StringComparison.OrdinalIgnoreCase)) { flag = true; } } break; } case TokenKind.NewLine: case TokenKind.EndOfInput: case TokenKind.RParen: case TokenKind.RCurly: case TokenKind.Semi: case TokenKind.AndAnd: case TokenKind.OrOr: case TokenKind.Ampersand: case TokenKind.Pipe: case TokenKind.Comma: case TokenKind.MinusMinus: case TokenKind.Redirection: case TokenKind.RedirectInStd: this.UngetToken(token); if (token2 != null) { this.ReportIncompleteInput(After(token2), ParserStrings.MissingExpression, new object[] { "," }); return new ErrorExpressionAst(ExtentOf(source.First<ExpressionAst>(), token2), (IEnumerable<Ast>)source); } return null; default: ast = new StringConstantExpressionAst(token.Extent, token.Text, StringConstantType.BareWord); switch (context) { case CommandArgumentContext.CommandName: case CommandArgumentContext.CommandNameAfterInvocationOperator: token.TokenFlags |= TokenFlags.CommandName; break; case CommandArgumentContext.FileName: case CommandArgumentContext.CommandArgument: case CommandArgumentContext.SwitchCondition: token.SetIsCommandArgument(); break; } break; } if ((context == CommandArgumentContext.CommandArgument) && !flag) { token = this.PeekToken(); if (token.Kind == TokenKind.Comma) { token2 = token; if (source == null) { source = new List<ExpressionAst>(); } source.Add(ast); this.SkipToken(); this.SkipNewlines(); token = this.NextToken(); goto Label_0006; } } if (source != null) { source.Add(ast); return new ArrayLiteralAst(ExtentOf(source.First<ExpressionAst>(), source.Last<ExpressionAst>()), source); } return ast; }
public void LastAssignmentStatementAst_should_be_null_when_not_VariableExpression() { var leftExpressionAst = new StringConstantExpressionAst(extent, varName, StringConstantType.BareWord); var assignmentStatementAst = GetAssignmentStatementAst(leftExpressionAst, TokenKind.Equals); visitor.VisitAssignmentStatement(assignmentStatementAst); visitor.LastAssignmentStatementAst.Should().BeNull(); }
public static void PatchCSharpCode(this PSScriptAst psScriptAst, string code, StringConstantExpressionAst ast) { var patchedAst = psScriptAst.ScriptBlockAst.Visit(new CSharpPatcher(code, ast, psScriptAst)) as ScriptBlockAst; psScriptAst.ScriptBlockAst = patchedAst; }
public override AstVisitAction VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { return(AstVisitAction.Continue); }
private ExpressionAst ExpandableStringRule(StringExpandableToken strToken) { //G value: //G literal ExpressionAst expr; // We need to scan the nested tokens even if there was some error. This is used by the tab completion: "pshome is $psh<tab> if (strToken.NestedTokens != null) { List<ExpressionAst> nestedExpressions = ParseNestedExpressions(strToken); expr = new ExpandableStringExpressionAst(strToken, strToken.Value, strToken.FormatString, nestedExpressions); } else { expr = new StringConstantExpressionAst(strToken); } return expr; }
public override AstVisitAction VisitStringConstantExpression(StringConstantExpressionAst ast) { return this.Check(ast); }
private ExpressionAst PrimaryExpressionRule(bool withMemberAccess) { //G primary-expression: //G value //G member-access //G element-access //G invocation-expression //G post-increment-expression //G post-decrement-expression //G value: //G parenthesized-expression //G sub-expression //G array-expression //G script-block-expression //G hash-literal-expression //G literal //G type-literal //G variable ExpressionAst expr; Token token = NextToken(); switch (token.Kind) { case TokenKind.SplattedVariable: case TokenKind.Variable: expr = CheckUsingVariable((VariableToken)token, withMemberAccess: withMemberAccess); break; case TokenKind.Number: expr = new ConstantExpressionAst((NumberToken)token); break; case TokenKind.HereStringExpandable: case TokenKind.StringExpandable: expr = ExpandableStringRule((StringExpandableToken)token); break; case TokenKind.HereStringLiteral: case TokenKind.StringLiteral: expr = new StringConstantExpressionAst((StringToken)token); break; case TokenKind.LParen: expr = ParenthesizedExpressionRule(token); break; case TokenKind.AtParen: case TokenKind.DollarParen: expr = SubExpressionRule(token); break; case TokenKind.AtCurly: expr = HashExpressionRule(token, false /* parsingSchemaElement */ ); break; case TokenKind.LCurly: expr = ScriptBlockExpressionRule(token); break; default: UngetToken(token); return null; } if (!withMemberAccess) { return expr; } return CheckPostPrimaryExpressionOperators(NextMemberAccessToken(true), expr); }
public override AstVisitAction VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { throw new NotImplementedException(); //VisitStringConstantExpression(stringConstantExpressionAst); }
private bool PrepareCommandElements(ExecutionContext context) { int num = 0; bool dotSource = this._commandAst.InvocationOperator == TokenKind.Dot; CommandProcessorBase base2 = null; string resolvedCommandName = null; bool flag2 = false; try { base2 = this.PrepareFromAst(context, out resolvedCommandName) ?? context.CreateCommand(resolvedCommandName, dotSource); } catch (RuntimeException exception) { CommandProcessorBase.CheckForSevereException(exception); if ((this._commandAst.IsInWorkflow() && (resolvedCommandName != null)) && CompletionCompleters.PseudoWorkflowCommands.Contains <string>(resolvedCommandName, StringComparer.OrdinalIgnoreCase)) { flag2 = true; } else { return(false); } } CommandProcessor commandProcessor = base2 as CommandProcessor; ScriptCommandProcessorBase base3 = base2 as ScriptCommandProcessorBase; bool flag3 = (commandProcessor != null) && commandProcessor.CommandInfo.ImplementsDynamicParameters; List <object> list = flag3 ? new List <object>(this._commandElements.Count) : null; if (((commandProcessor != null) || (base3 != null)) || flag2) { num++; while (num < this._commandElements.Count) { CommandParameterAst parameterAst = this._commandElements[num] as CommandParameterAst; if (parameterAst != null) { if (list != null) { list.Add(parameterAst.Extent.Text); } AstPair item = (parameterAst.Argument != null) ? new AstPair(parameterAst, parameterAst.Argument) : new AstPair(parameterAst); this._arguments.Add(item); } else { StringConstantExpressionAst ast2 = this._commandElements[num] as StringConstantExpressionAst; if ((ast2 == null) || !ast2.Value.Trim().Equals("-", StringComparison.OrdinalIgnoreCase)) { ExpressionAst argumentAst = this._commandElements[num] as ExpressionAst; if (argumentAst != null) { if (list != null) { list.Add(argumentAst.Extent.Text); } this._arguments.Add(new AstPair(null, argumentAst)); } } } num++; } } if (commandProcessor != null) { this._function = false; if (flag3) { ParameterBinderController.AddArgumentsToCommandProcessor(commandProcessor, list.ToArray()); bool flag4 = false; bool flag5 = false; do { CommandProcessorBase currentCommandProcessor = context.CurrentCommandProcessor; try { context.CurrentCommandProcessor = commandProcessor; commandProcessor.SetCurrentScopeToExecutionScope(); if (!flag4) { commandProcessor.CmdletParameterBinderController.BindCommandLineParametersNoValidation(commandProcessor.arguments); } else { flag5 = true; commandProcessor.CmdletParameterBinderController.ClearUnboundArguments(); commandProcessor.CmdletParameterBinderController.BindCommandLineParametersNoValidation(new Collection <CommandParameterInternal>()); } } catch (ParameterBindingException exception2) { if ((exception2.ErrorId == "MissingArgument") || (exception2.ErrorId == "AmbiguousParameter")) { flag4 = true; } } catch (Exception exception3) { CommandProcessorBase.CheckForSevereException(exception3); } finally { context.CurrentCommandProcessor = currentCommandProcessor; commandProcessor.RestorePreviousScope(); } }while (flag4 && !flag5); } this._commandInfo = commandProcessor.CommandInfo; this._commandName = commandProcessor.CommandInfo.Name; this._bindableParameters = commandProcessor.CmdletParameterBinderController.BindableParameters; this._defaultParameterSetFlag = commandProcessor.CommandInfo.CommandMetadata.DefaultParameterSetFlag; } else if (base3 != null) { this._function = true; this._commandInfo = base3.CommandInfo; this._commandName = base3.CommandInfo.Name; this._bindableParameters = base3.ScriptParameterBinderController.BindableParameters; this._defaultParameterSetFlag = 0; } else if (!flag2) { return(false); } if (this._commandAst.IsInWorkflow()) { Type type = Type.GetType("Microsoft.PowerShell.Workflow.AstToWorkflowConverter, Microsoft.PowerShell.Activities, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"); if (type != null) { Dictionary <string, Type> dictionary = (Dictionary <string, Type>)type.GetMethod("GetActivityParameters").Invoke(null, new object[] { this._commandAst }); if (dictionary != null) { bool flag6 = dictionary.ContainsKey("PSComputerName") && !dictionary.ContainsKey("ComputerName"); List <MergedCompiledCommandParameter> source = new List <MergedCompiledCommandParameter>(); Collection <Attribute> attributes = new Collection <Attribute> { new ParameterAttribute() }; foreach (KeyValuePair <string, Type> pair2 in dictionary) { if (flag2 || !this._bindableParameters.BindableParameters.ContainsKey(pair2.Key)) { Type actualActivityParameterType = GetActualActivityParameterType(pair2.Value); RuntimeDefinedParameter runtimeDefinedParameter = new RuntimeDefinedParameter(pair2.Key, actualActivityParameterType, attributes); CompiledCommandParameter parameter = new CompiledCommandParameter(runtimeDefinedParameter, false) { IsInAllSets = true }; MergedCompiledCommandParameter parameter3 = new MergedCompiledCommandParameter(parameter, ParameterBinderAssociation.DeclaredFormalParameters); source.Add(parameter3); } } if (source.Any <MergedCompiledCommandParameter>()) { MergedCommandParameterMetadata metadata = new MergedCommandParameterMetadata(); if (!flag2) { metadata.ReplaceMetadata(this._bindableParameters); } foreach (MergedCompiledCommandParameter parameter5 in source) { metadata.BindableParameters.Add(parameter5.Parameter.Name, parameter5); } this._bindableParameters = metadata; } foreach (string str2 in ignoredWorkflowParameters) { if (this._bindableParameters.BindableParameters.ContainsKey(str2)) { this._bindableParameters.BindableParameters.Remove(str2); } } if (this._bindableParameters.BindableParameters.ContainsKey("ComputerName") && flag6) { this._bindableParameters.BindableParameters.Remove("ComputerName"); string key = (from aliasPair in this._bindableParameters.AliasedParameters where string.Equals("ComputerName", aliasPair.Value.Parameter.Name) select aliasPair.Key).FirstOrDefault <string>(); this._bindableParameters.AliasedParameters.Remove(key); } } } } this._unboundParameters.AddRange(this._bindableParameters.BindableParameters.Values); CommandBaseAst ast4 = null; PipelineAst parent = this._commandAst.Parent as PipelineAst; if (parent.PipelineElements.Count > 1) { foreach (CommandBaseAst ast6 in parent.PipelineElements) { if (ast6.GetHashCode() == this._commandAst.GetHashCode()) { this._isPipelineInputExpected = ast4 != null; if (this._isPipelineInputExpected) { this._pipelineInputType = typeof(object); } break; } ast4 = ast6; } } return(true); }
public object VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { CheckIsConstant(stringConstantExpressionAst, "Caller to verify ast is constant"); return stringConstantExpressionAst.Value; }
public override AstVisitAction VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { this._pipelineCommandRuntime.outputResults.Write(stringConstantExpressionAst.Value); return AstVisitAction.SkipChildren; }
/// <summary/> public virtual AstVisitAction VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { return(AstVisitAction.Continue); }
internal Ast CommandRule(bool forDynamicKeyword) { //G command: //G command-name command-elements:opt //G command-invocation-operator command-module:opt command-name-expr command-elements:opt //G command-invocation-operator: one of //G '&' '.' //G command-module: //G primary-expression //G command-name: //G generic-token //G generic-token-with-subexpr //G generic-token-with-subexpr: No whitespace is allowed between ) and command-name. //G generic-token-with-subexpr-start statement-list:opt ) command-name //G command-name-expr: //G command-name //G primary-expression //G command-elements: //G command-element //G command-elements command-element //G command-element: //G command-parameter //G command-argument //G redirection //G command-argument: //G command-name-expr Token firstToken; bool dotSource, ampersand; bool sawDashDash = false; bool foundVerbatimArgument = false; RedirectionAst[] redirections = null; IScriptExtent endExtent; var elements = new List<CommandElementAst>(); var oldTokenizerMode = _tokenizer.Mode; try { SetTokenizerMode(TokenizerMode.Command); Token token = NextToken(); firstToken = token; endExtent = token.Extent; dotSource = false; ampersand = false; CommandArgumentContext context; if (token.Kind == TokenKind.Dot) { dotSource = true; token = NextToken(); context = CommandArgumentContext.CommandNameAfterInvocationOperator; } else if (token.Kind == TokenKind.Ampersand) { ampersand = true; token = NextToken(); context = CommandArgumentContext.CommandNameAfterInvocationOperator; } else { context = CommandArgumentContext.CommandName; } bool scanning = true; while (scanning) { switch (token.Kind) { case TokenKind.Pipe: case TokenKind.RCurly: case TokenKind.RParen: case TokenKind.EndOfInput: case TokenKind.NewLine: case TokenKind.Semi: case TokenKind.AndAnd: case TokenKind.OrOr: UngetToken(token); scanning = false; continue; case TokenKind.Ampersand: // ErrorRecovery: just ignore the token. endExtent = token.Extent; ReportError(token.Extent, () => ParserStrings.AmpersandNotAllowed); break; case TokenKind.MinusMinus: endExtent = token.Extent; // Add the first -- as a parameter, which is then ignored when constructing the command processor unless it's a native // command. All subsequent -- are added as arguments. elements.Add(sawDashDash ? (CommandElementAst)new StringConstantExpressionAst(token.Extent, token.Text, StringConstantType.BareWord) : new CommandParameterAst(token.Extent, "-", null, token.Extent)); sawDashDash = true; break; case TokenKind.Comma: endExtent = token.Extent; ReportError(token.Extent, () => ParserStrings.MissingArgument); SkipNewlines(); break; case TokenKind.Parameter: if ((context & CommandArgumentContext.CommandName) != 0 || sawDashDash) { endExtent = token.Extent; token.TokenFlags |= TokenFlags.CommandName; var commandName = new StringConstantExpressionAst(token.Extent, token.Text, StringConstantType.BareWord); elements.Add(commandName); break; } var parameterToken = (ParameterToken)token; ExpressionAst parameterArgs; IScriptExtent extent; // If the next token is a comma, don't grab it as part of the argument. The next time through this // loop will issue an error. if (parameterToken.UsedColon && PeekToken().Kind != TokenKind.Comma) { parameterArgs = GetCommandArgument(CommandArgumentContext.CommandArgument, NextToken()); if (parameterArgs == null) { extent = parameterToken.Extent; ReportError(After(extent), () => ParserStrings.ParameterRequiresArgument, parameterToken.Text); } else { extent = ExtentOf(token, parameterArgs); } } else { parameterArgs = null; extent = token.Extent; } endExtent = extent; var paramAst = new CommandParameterAst(extent, parameterToken.ParameterName, parameterArgs, token.Extent); elements.Add(paramAst); break; case TokenKind.Redirection: case TokenKind.RedirectInStd: if ((context & CommandArgumentContext.CommandName) == 0) { if (redirections == null) { redirections = new RedirectionAst[CommandBaseAst.MaxRedirections]; } RedirectionRule((RedirectionToken)token, redirections, ref endExtent); } else { // For backwards compatibility, we allow redirection operators as command names. // V2 did not allow: // & << // but V3 and on will because it falls out rather naturally here. endExtent = token.Extent; elements.Add(new StringConstantExpressionAst(token.Extent, token.Text, StringConstantType.BareWord)); } break; default: if (token.Kind == TokenKind.InlineScript && context == CommandArgumentContext.CommandName) { scanning = InlineScriptRule(token, elements); Diagnostics.Assert(elements.Count >= 1, "We should at least have the command name: inlinescript"); endExtent = elements.Last().Extent; if (!scanning) { continue; } } else { var ast = GetCommandArgument(context, token); // If this is the special verbatim argument syntax, look for the next element StringToken argumentToken = token as StringToken; if ((argumentToken != null) && String.Equals(argumentToken.Value, VERBATIM_ARGUMENT, StringComparison.OrdinalIgnoreCase)) { elements.Add(ast); endExtent = ast.Extent; var verbatimToken = GetVerbatimCommandArgumentToken(); if (verbatimToken != null) { foundVerbatimArgument = true; scanning = false; ast = new StringConstantExpressionAst(verbatimToken.Extent, verbatimToken.Value, StringConstantType.BareWord); elements.Add(ast); endExtent = ast.Extent; } break; } endExtent = ast.Extent; elements.Add(ast); } break; } if (!foundVerbatimArgument) { context = CommandArgumentContext.CommandArgument; token = NextToken(); } } } finally { SetTokenizerMode(oldTokenizerMode); } if (elements.Count == 0) { Diagnostics.Assert(!forDynamicKeyword, "DynamicKeyword should have command name at least"); if (dotSource || ampersand) { IScriptExtent extent = firstToken.Extent; ReportError(extent, () => ParserStrings.MissingExpression, firstToken.Text); } return null; } if (forDynamicKeyword) { // TODO: report error if any redirections return new DynamicKeywordStatementAst(ExtentOf(firstToken, endExtent), elements); } return new CommandAst(ExtentOf(firstToken, endExtent), elements, dotSource || ampersand ? firstToken.Kind : TokenKind.Unknown, redirections != null ? redirections.Where(r => r != null) : null); }
public object VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { CheckIsConstant(stringConstantExpressionAst, "Caller to verify ast is constant"); return(stringConstantExpressionAst.Value); }
private ExpressionAst GetCommandArgument(CommandArgumentContext context, Token token) { Diagnostics.Assert(token.Kind != TokenKind.Comma, "A unary comma is an error in command mode, and should have already been reported."); ExpressionAst exprAst; List<ExpressionAst> commandArgs = null; Token commaToken = null; bool foundVerbatimArgument = false; while (true) { switch (token.Kind) { // The following tokens are never allowed as command arguments. case TokenKind.Pipe: case TokenKind.RCurly: case TokenKind.RParen: case TokenKind.EndOfInput: case TokenKind.NewLine: case TokenKind.Semi: case TokenKind.Redirection: case TokenKind.RedirectInStd: case TokenKind.AndAnd: case TokenKind.OrOr: case TokenKind.Ampersand: case TokenKind.MinusMinus: case TokenKind.Comma: UngetToken(token); // If we haven't seen an argument, the caller must issue an error. If we've seen at least one // argument, then we will issue the error and return back the arguments seen so far. if (commaToken == null) { return null; } // ErrorRecovery: stop looking for additional arguments, exclude the trailing comma ReportIncompleteInput(After(commaToken), () => ParserStrings.MissingExpression, ","); return new ErrorExpressionAst(ExtentOf(commandArgs.First(), commaToken), commandArgs); case TokenKind.SplattedVariable: case TokenKind.Variable: case TokenKind.Number: case TokenKind.HereStringExpandable: case TokenKind.StringExpandable: case TokenKind.HereStringLiteral: case TokenKind.StringLiteral: case TokenKind.LParen: case TokenKind.DollarParen: case TokenKind.AtParen: case TokenKind.AtCurly: case TokenKind.LCurly: UngetToken(token); exprAst = PrimaryExpressionRule(withMemberAccess: true); Diagnostics.Assert(exprAst != null, "PrimaryExpressionRule should never return null"); break; case TokenKind.Generic: if ((context & CommandArgumentContext.CommandName) != 0) { token.TokenFlags |= TokenFlags.CommandName; } var genericToken = (StringToken)token; var expandableToken = genericToken as StringExpandableToken; // A command name w/o invocation operator is not expandable even if the token has expandable parts // If we have seen an invocation operator, the command name is expandable. if (expandableToken != null && context != CommandArgumentContext.CommandName) { var nestedExpressions = ParseNestedExpressions(expandableToken); exprAst = new ExpandableStringExpressionAst(expandableToken, expandableToken.Value, expandableToken.FormatString, nestedExpressions); } else { exprAst = new StringConstantExpressionAst(genericToken.Extent, genericToken.Value, StringConstantType.BareWord); // If this is a verbatim argument, then don't continue peeking if (String.Equals(genericToken.Value, VERBATIM_ARGUMENT, StringComparison.OrdinalIgnoreCase)) { foundVerbatimArgument = true; } } break; default: exprAst = new StringConstantExpressionAst(token.Extent, token.Text, StringConstantType.BareWord); // A command/argument that matches a keyword isn't really a keyword, so don't color it that way token.TokenFlags &= ~TokenFlags.Keyword; switch (context) { case CommandArgumentContext.CommandName: case CommandArgumentContext.CommandNameAfterInvocationOperator: token.TokenFlags |= TokenFlags.CommandName; break; case CommandArgumentContext.FileName: case CommandArgumentContext.CommandArgument: case CommandArgumentContext.SwitchCondition: token.SetIsCommandArgument(); break; } break; } if (context != CommandArgumentContext.CommandArgument) { break; } if (foundVerbatimArgument) { break; } token = PeekToken(); if (token.Kind != TokenKind.Comma) { break; } commaToken = token; if (commandArgs == null) { commandArgs = new List<ExpressionAst>(); } commandArgs.Add(exprAst); SkipToken(); SkipNewlines(); token = NextToken(); } Diagnostics.Assert(commandArgs != null || exprAst != null, "How did that happen?"); if (commandArgs != null) { commandArgs.Add(exprAst); return new ArrayLiteralAst(ExtentOf(commandArgs[0], commandArgs[commandArgs.Count - 1]), commandArgs); } return exprAst; }
private StringConstantExpressionAst ResolveUsingAssembly(StringConstantExpressionAst name) { var assemblyName = name.Value; Uri uri; // assemblyName can be invalid, i.e. during typing. // We only use uri to check that we don't allow UNC paths. if (Uri.TryCreate(assemblyName, UriKind.Absolute, out uri)) { if (uri.IsUnc) { ReportError(name.Extent, () => ParserStrings.CannotLoadAssemblyFromUncPath, assemblyName); } // don't allow things like 'using assembly http://microsoft.com' if (uri.Scheme != "file") { ReportError(name.Extent, () => ParserStrings.CannotLoadAssemblyWithUriSchema, uri.Scheme); } } else { string assemblyFileName = assemblyName; try { var scriptFileName = name.Extent.File; if (!Path.IsPathRooted(assemblyFileName)) { string workingDirectory; if (string.IsNullOrEmpty(scriptFileName)) { // We are in REPL, or Invoke-Expression, or ScriptBlock.Create, etc. // It's legal to use '.\foo.dll', and we should do lookup in $pwd. // We resolving it in parse time to avoid difference in script behavior, // when script execution is delayed from parsing, i.e. // $script = [scriptblock]::Create('using assembly .\foo.dll; [Foo].foo()') // # using assembly behavior should be the same in these two cases: // cd A; $script.Invoke() // cd B; $script.Invoke() if (Runspaces.Runspace.DefaultRunspace != null) { workingDirectory = Runspaces.Runspace.DefaultRunspace.ExecutionContext.EngineIntrinsics.SessionState.Path.CurrentLocation.Path; } else { // In this case, our best guess is process working directory. workingDirectory = Directory.GetCurrentDirectory(); } } else { workingDirectory = Path.GetDirectoryName(scriptFileName); } assemblyFileName = workingDirectory + @"\" + assemblyFileName; } #if !CORECLR if (!File.Exists(assemblyFileName)) { GlobalAssemblyCache.ResolvePartialName(assemblyName, out assemblyFileName); } #endif } catch { } if (assemblyFileName == null || !File.Exists(assemblyFileName)) { ReportError(name.Extent, () => ParserStrings.ErrorLoadingAssembly, assemblyName); } else { return new StringConstantExpressionAst(name.Extent, assemblyFileName, name.StringConstantType); } } return name; }
public override AstVisitAction VisitStringConstantExpression(StringConstantExpressionAst ast) { return(Check(ast)); }
public object VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { _visitCount++; return true; }
public object VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { _visitCount++; return(true); }
private ExpressionAst ExpandableStringRule(StringExpandableToken strToken) { ExpressionAst stringConstantExpressionAst; if (strToken.NestedTokens == null) { stringConstantExpressionAst = new StringConstantExpressionAst(strToken); } else { List<ExpressionAst> expressionAsts = this.ParseNestedExpressions(strToken); stringConstantExpressionAst = new ExpandableStringExpressionAst(strToken, strToken.Value, strToken.FormatString, expressionAsts); } return stringConstantExpressionAst; }
public object VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst) { return(true); }
internal override IEnumerable <PSTypeName> GetInferredType(CompletionContext context) { StringConstantExpressionAst member = this.Member as StringConstantExpressionAst; if (member != null) { PSTypeName[] iteratorVariable1; if (this.Static) { TypeExpressionAst expression = this.Expression as TypeExpressionAst; if (expression == null) { goto Label_064A; } Type type = expression.TypeName.GetReflectionType(); if (type == null) { goto Label_064A; } iteratorVariable1 = new PSTypeName[] { new PSTypeName(type) }; } else { iteratorVariable1 = this.Expression.GetInferredType(context).ToArray <PSTypeName>(); if (iteratorVariable1.Length == 0) { goto Label_064A; } } List <string> iteratorVariable2 = new List <string> { member.Value }; foreach (PSTypeName iteratorVariable3 in iteratorVariable1) { IEnumerable <object> iteratorVariable4 = CompletionCompleters.GetMembersByInferredType(iteratorVariable3, this.Static, context); for (int i = 0; i < iteratorVariable2.Count; i++) { string iteratorVariable6 = iteratorVariable2[i]; foreach (object iteratorVariable7 in iteratorVariable4) { PropertyInfo iteratorVariable8 = iteratorVariable7 as PropertyInfo; if (iteratorVariable8 != null) { if (iteratorVariable8.Name.Equals(iteratorVariable6, StringComparison.OrdinalIgnoreCase) && !(this is InvokeMemberExpressionAst)) { yield return(new PSTypeName(iteratorVariable8.PropertyType)); break; } } else { FieldInfo iteratorVariable9 = iteratorVariable7 as FieldInfo; if (iteratorVariable9 != null) { if (iteratorVariable9.Name.Equals(iteratorVariable6, StringComparison.OrdinalIgnoreCase) && !(this is InvokeMemberExpressionAst)) { yield return(new PSTypeName(iteratorVariable9.FieldType)); break; } continue; } DotNetAdapter.MethodCacheEntry iteratorVariable10 = iteratorVariable7 as DotNetAdapter.MethodCacheEntry; if (iteratorVariable10 != null) { if (iteratorVariable10[0].method.Name.Equals(iteratorVariable6, StringComparison.OrdinalIgnoreCase)) { if (!(this is InvokeMemberExpressionAst)) { yield return(new PSTypeName(typeof(PSMethod))); break; } foreach (MethodInformation iteratorVariable11 in iteratorVariable10.methodInformationStructures) { MethodInfo method = iteratorVariable11.method as MethodInfo; if ((method != null) && !method.ReturnType.ContainsGenericParameters) { yield return(new PSTypeName(method.ReturnType)); } } break; } continue; } PSMemberInfo iteratorVariable13 = iteratorVariable7 as PSMemberInfo; if ((iteratorVariable13 != null) && iteratorVariable13.Name.Equals(iteratorVariable6, StringComparison.OrdinalIgnoreCase)) { PSNoteProperty iteratorVariable14 = iteratorVariable7 as PSNoteProperty; if (iteratorVariable14 != null) { yield return(new PSTypeName(iteratorVariable14.Value.GetType())); break; } PSAliasProperty iteratorVariable15 = iteratorVariable7 as PSAliasProperty; if (iteratorVariable15 != null) { iteratorVariable2.Add(iteratorVariable15.ReferencedMemberName); } else { PSCodeProperty iteratorVariable16 = iteratorVariable7 as PSCodeProperty; if (iteratorVariable16 != null) { if (iteratorVariable16.GetterCodeReference != null) { yield return(new PSTypeName(iteratorVariable16.GetterCodeReference.ReturnType)); break; } } else { ScriptBlock getterScript = null; PSScriptProperty iteratorVariable18 = iteratorVariable7 as PSScriptProperty; if (iteratorVariable18 != null) { getterScript = iteratorVariable18.GetterScript; } PSScriptMethod iteratorVariable19 = iteratorVariable7 as PSScriptMethod; if (iteratorVariable19 != null) { getterScript = iteratorVariable19.Script; } if (getterScript != null) { foreach (PSTypeName iteratorVariable20 in getterScript.OutputType) { yield return(iteratorVariable20); } } } } break; } } } } } } Label_064A: yield break; }
public void Setup() { this._commandExpressionAst = ParseStatement("'PS> '") .PipelineElements[0]; this._stringConstantExpressionAst = (StringConstantExpressionAst)this._commandExpressionAst.Expression; }
/// <summary> /// Parse a dynamic keyword statement which will be either of the form /// keyword [parameters] [name] { a=1; b=2; } # constructor with properties /// or /// keyword [parameters] [name] { ... } # constructor with a simple body. /// or keywordcommand parameters /// This custom keyword does not introduce a new AST node type. Instead it generates a /// CommandAst that calls a PowerShell command to implement the keyword's logic. /// This command has one of two signatures: /// keywordImplCommand /// </summary> /// <param name="functionName">The name of the function to invoke</param> /// <param name="keywordData">The data for this keyword definition</param> /// <returns></returns> private StatementAst DynamicKeywordStatementRule(Token functionName, DynamicKeyword keywordData) { ////////////////////////////////////////////////////////////////////////////////// // If a custom action was provided. then invoke it ////////////////////////////////////////////////////////////////////////////////// if (keywordData.PreParse != null) { try { ParseError[] errors = keywordData.PreParse(keywordData); if (errors != null && errors.Length > 0) { foreach (var e in errors) { ReportError(e); } } } catch (Exception e) { ReportError(functionName.Extent, () => ParserStrings.DynamicKeywordPreParseException, keywordData.ResourceName, e.ToString()); return null; } } if (keywordData.IsReservedKeyword) { // ErrorRecovery: eat the token ReportError(functionName.Extent, () => ParserStrings.UnsupportedReservedKeyword, keywordData.Keyword); return null; } if (keywordData.HasReservedProperties) { // ErrorRecovery: eat the token ReportError(functionName.Extent, () => ParserStrings.UnsupportedReservedProperty, "'Require', 'Trigger', 'Notify', 'Before', 'After' and 'Subscribe'"); return null; } string elementName = string.Empty; DynamicKeywordStatementAst dynamicKeywordAst; if (keywordData.BodyMode == DynamicKeywordBodyMode.Command) { UngetToken(functionName); dynamicKeywordAst = (DynamicKeywordStatementAst)CommandRule(forDynamicKeyword: true); dynamicKeywordAst.Keyword = keywordData; dynamicKeywordAst.FunctionName = functionName; } else { SkipNewlines(); // The expression that returns the resource name or names. ExpressionAst instanceName = null; Token nameToken = NextToken(); if (nameToken.Kind == TokenKind.EndOfInput) { UngetToken(nameToken); if (keywordData.NameMode == DynamicKeywordNameMode.NameRequired || keywordData.NameMode == DynamicKeywordNameMode.SimpleNameRequired) { ReportIncompleteInput(After(functionName), () => ParserStrings.RequiredNameOrExpressionMissing); } else { // Name not required so report missing brace ReportIncompleteInput(After(functionName.Extent), () => ParserStrings.MissingBraceInObjectDefinition); } return null; } // If it's an lcurly, then no name was provided, and we skip to the body processing Token lCurly = null; if (nameToken.Kind == TokenKind.LCurly) { lCurly = nameToken; if (keywordData.NameMode == DynamicKeywordNameMode.NameRequired || keywordData.NameMode == DynamicKeywordNameMode.SimpleNameRequired) { ReportError(After(functionName), () => ParserStrings.RequiredNameOrExpressionMissing); UngetToken(nameToken); return null; } } else if (nameToken.Kind == TokenKind.Identifier || nameToken.Kind == TokenKind.DynamicKeyword) { if (keywordData.NameMode == DynamicKeywordNameMode.NoName) { ReportError(After(functionName), () => ParserStrings.UnexpectedNameForType, functionName.Text, nameToken.Text); UngetToken(nameToken); return null; } // If it's an identifier then this is the name for the data object elementName = nameToken.Text; // If only a simple name is allowed, then the string must be non-null. if ((keywordData.NameMode == DynamicKeywordNameMode.SimpleNameRequired || keywordData.NameMode == DynamicKeywordNameMode.SimpleOptionalName) && string.IsNullOrEmpty(elementName)) { ReportIncompleteInput(After(functionName), () => ParserStrings.RequiredNameOrExpressionMissing); UngetToken(nameToken); return null; } } else { // see if an expression was provided instead of a bare word... UngetToken(nameToken); instanceName = GetSingleCommandArgument(CommandArgumentContext.CommandName); if (instanceName == null) { if (keywordData.NameMode == DynamicKeywordNameMode.SimpleNameRequired || keywordData.NameMode == DynamicKeywordNameMode.SimpleOptionalName) { ReportError(After(functionName), () => ParserStrings.RequiredNameOrExpressionMissing); } else { // It wasn't an '{' and it wasn't a name expression so it's a unexpected token. ReportError(After(functionName), () => ParserStrings.UnexpectedToken, nameToken.Text); } return null; } // Ok, we got a name expression, but we're expecting no name, so it's and error. if (keywordData.NameMode == DynamicKeywordNameMode.NoName) { ReportError(After(functionName), () => ParserStrings.UnexpectedNameForType, functionName.Text, instanceName.ToString()); return null; } // We were expecting a simple name so report an error if (keywordData.NameMode == DynamicKeywordNameMode.SimpleNameRequired || keywordData.NameMode == DynamicKeywordNameMode.SimpleOptionalName) { // If no match, then this is an incomplete token BUGBUG fix message ReportError(nameToken.Extent, () => ParserStrings.UnexpectedToken, nameToken.Text); return null; } } // If we didn't get a resource expression AST, then we need to build one out of the // name that was specified. It may be the case that we don't have // a resource name in which case it will be the empty string. Even in the cases were // we aren't expecting a name, we still do this so that the signature of the implementing function remains // the same. ExpressionAst originalInstanceName = instanceName; if (instanceName == null) { instanceName = new StringConstantExpressionAst(nameToken.Extent, elementName, StringConstantType.BareWord); } SkipNewlines(); // // Now look for the body of the data statement. // if (lCurly == null) { lCurly = NextToken(); if (lCurly.Kind == TokenKind.EndOfInput) { UngetToken(lCurly); ReportIncompleteInput(After(functionName.Extent), () => ParserStrings.MissingBraceInObjectDefinition); // Preserve the name expression for tab completion return originalInstanceName == null ? null : new ErrorStatementAst(ExtentOf(functionName, originalInstanceName), GetNestedErrorAsts(originalInstanceName)); } if (lCurly.Kind != TokenKind.LCurly) { // We need to generate a reasonable error message for this case: // // Configuration C { // node $AllNode.NodeName{ # There is no space before curly, and we are converting scriptblock to and argument to call 'NodeName' // ... // } // } # we don't want to simple report an unexpected token here, it would be super-confusing. InvokeMemberExpressionAst instanceInvokeMemberExpressionAst = instanceName as InvokeMemberExpressionAst; if (instanceInvokeMemberExpressionAst != null && instanceInvokeMemberExpressionAst.Arguments.Count == 1 && instanceInvokeMemberExpressionAst.Arguments[0] is ScriptBlockExpressionAst && // the last condition checks that there is no space between "method" name and '{' instanceInvokeMemberExpressionAst.Member.Extent.EndOffset == instanceInvokeMemberExpressionAst.Arguments[0].Extent.StartOffset) { ReportError(LastCharacterOf(instanceInvokeMemberExpressionAst.Member.Extent), () => ParserStrings.UnexpectedTokenInDynamicKeyword, functionName.Text); } else { ReportError(lCurly.Extent, () => ParserStrings.UnexpectedToken, lCurly.Text); } if (lCurly.Kind == TokenKind.Dot && originalInstanceName != null && lCurly.Extent.StartOffset == originalInstanceName.Extent.EndOffset) { // Generate more useful ast for tab-completing extension methods on special DSC collection variables // e.g. configuration foo { node $AllNodes.<tab> IScriptExtent errorExtent = ExtentOf(originalInstanceName, lCurly); var errorExpr = new ErrorExpressionAst(errorExtent); var memberExpr = new MemberExpressionAst(originalInstanceName.Extent, originalInstanceName, errorExpr, @static: false); return new ErrorStatementAst(errorExtent, new[] { memberExpr }); } UngetToken(lCurly); // Preserve the name expression for tab completion return originalInstanceName == null ? null : new ErrorStatementAst(ExtentOf(functionName, originalInstanceName), GetNestedErrorAsts(originalInstanceName)); } } // // The keyword data is used to see // if a scriptblock or a hashtable is expected. // ExpressionAst body = null; if (keywordData.BodyMode == DynamicKeywordBodyMode.ScriptBlock) { var oldInConfiguraiton = _inConfiguration; try { _inConfiguration = false; body = ScriptBlockExpressionRule(lCurly); } finally { _inConfiguration = oldInConfiguraiton; } } else if (keywordData.BodyMode == DynamicKeywordBodyMode.Hashtable) { // Resource property value could be set to nested DSC resources except Script resource bool isScriptResource = String.Compare(functionName.Text, @"Script", StringComparison.OrdinalIgnoreCase) == 0; try { if (isScriptResource) DynamicKeyword.Push(); body = HashExpressionRule(lCurly, true /* parsingSchemaElement */); } finally { if (isScriptResource) DynamicKeyword.Pop(); } } // commandast // elements: instancename/dynamickeyword/hashtable or scripblockexpress if (body == null) { // Failed to read the statement body ReportIncompleteInput(After(lCurly), () => ParserStrings.MissingStatementAfterKeyword, keywordData.Keyword); // Preserve the name expression for tab completion return originalInstanceName == null ? null : new ErrorStatementAst(ExtentOf(functionName, originalInstanceName), GetNestedErrorAsts(originalInstanceName)); } ////////////////////////////////////////////////////////////////////////// // The statement is now fully parsed ////////////////////////////////////////////////////////////////////////// // // Create DynamicKeywordStatementAst // Collection<CommandElementAst> commandElements = new Collection<CommandElementAst> { new StringConstantExpressionAst(functionName.Extent, functionName.Text, StringConstantType.BareWord), (ExpressionAst)instanceName.Copy(), (ExpressionAst)body.Copy() }; Token nextToken = NextToken(); IScriptExtent dynamicKeywordExtent = ExtentOf(functionName, Before(nextToken)); UngetToken(nextToken); dynamicKeywordAst = new DynamicKeywordStatementAst(dynamicKeywordExtent, commandElements) { Keyword = keywordData, LCurly = lCurly, FunctionName = functionName, InstanceName = instanceName, OriginalInstanceName = originalInstanceName, BodyExpression = body, ElementName = elementName, }; } ////////////////////////////////////////////////////////////////////////////////// // If a custom action was provided. then invoke it ////////////////////////////////////////////////////////////////////////////////// if (keywordData.PostParse != null) { try { ParseError[] errors = keywordData.PostParse(dynamicKeywordAst); if (errors != null && errors.Length > 0) { foreach (var e in errors) { ReportError(e); } } } catch (Exception e) { ReportError(functionName.Extent, () => ParserStrings.DynamicKeywordPostParseException, keywordData.Keyword, e.ToString()); return null; } } return dynamicKeywordAst; }