public MemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst member, bool @static) : base(extent) { this.Expression = expression; this.Member = member; this.Static = @static; }
/// <summary> /// Condition on the parameter that must be satisfied for the error to be raised. /// </summary> /// <param name="CmdAst"></param> /// <param name="CeAst"></param> /// <returns></returns> public override bool ParameterCondition(CommandAst CmdAst, CommandElementAst CeAst) { if (CeAst is CommandParameterAst) { CommandParameterAst cmdParamAst = CeAst as CommandParameterAst; if (String.Equals(cmdParamAst.ParameterName, "computername", StringComparison.OrdinalIgnoreCase)) { List<string> localhostRepresentations = new List<string> { "localhost", ".", "::1", "127.0.0.1" }; Ast computerNameArgument = GetComputerNameArg(CmdAst, cmdParamAst.Extent.StartOffset); if (null != computerNameArgument) { if (!localhostRepresentations.Contains(computerNameArgument.Extent.Text.ToLower())) { return computerNameArgument is ConstantExpressionAst; } return false; } if (null != cmdParamAst.Argument && !localhostRepresentations.Contains(cmdParamAst.Argument.ToString().Replace("\"", "").Replace("'", "").ToLower())) { return cmdParamAst.Argument is ConstantExpressionAst; } } } return false; }
public InvokeMemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst method, IEnumerable<ExpressionAst> arguments, bool @static) : base(extent, expression, method, @static) { if ((arguments != null) && arguments.Any<ExpressionAst>()) { this.Arguments = new ReadOnlyCollection<ExpressionAst>(arguments.ToArray<ExpressionAst>()); base.SetParents((IEnumerable<Ast>) this.Arguments); } }
private static bool IsParameterName(CommandElementAst ast, string name) { var constantAst = ast as CommandParameterAst; if (constantAst == null) { return false; } return String.Equals(constantAst.ParameterName, name, StringComparison.OrdinalIgnoreCase); }
private static ConstantExpressionAst GetRootConstantExpression(CommandElementAst element) { while (element is MemberExpressionAst) { var memberExpression = (MemberExpressionAst)element; element = memberExpression.Expression; } return element as ConstantExpressionAst; }
public MemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst member, bool @static) : base(extent) { if ((expression == null) || (member == null)) { throw PSTraceSource.NewArgumentNullException((expression == null) ? "expression" : "member"); } this.Expression = expression; base.SetParent(expression); this.Member = member; base.SetParent(member); this.Static = @static; }
internal AstPair(CommandParameterAst parameterAst) { if ((parameterAst == null) || (parameterAst.Argument == null)) { throw PSTraceSource.NewArgumentException("parameterAst"); } base.Parameter = parameterAst; base.ParameterArgumentType = AstParameterArgumentType.AstPair; base.ParameterSpecified = true; base.ArgumentSpecified = true; base.ParameterName = parameterAst.ParameterName; base.ParameterText = "-" + base.ParameterName + ":"; base.ArgumentType = parameterAst.Argument.StaticType; this._parameterContainsArgument = true; this._argument = parameterAst.Argument; }
internal AstPair(CommandParameterAst parameterAst, ExpressionAst argumentAst) { if ((parameterAst != null) && (parameterAst.Argument != null)) { throw PSTraceSource.NewArgumentException("parameterAst"); } if ((parameterAst == null) && (argumentAst == null)) { throw PSTraceSource.NewArgumentNullException("argumentAst"); } base.Parameter = parameterAst; base.ParameterArgumentType = AstParameterArgumentType.AstPair; base.ParameterSpecified = parameterAst != null; base.ArgumentSpecified = argumentAst != null; base.ParameterName = (parameterAst != null) ? parameterAst.ParameterName : null; base.ParameterText = (parameterAst != null) ? parameterAst.ParameterName : null; base.ArgumentType = (argumentAst != null) ? argumentAst.StaticType : null; this._parameterContainsArgument = false; this._argument = argumentAst; }
internal AstPair(CommandParameterAst parameterAst, ExpressionAst argumentAst) { if ((parameterAst != null) && (parameterAst.Argument != null)) { throw PSTraceSource.NewArgumentException("parameterAst"); } if ((parameterAst == null) && (argumentAst == null)) { throw PSTraceSource.NewArgumentNullException("argumentAst"); } base.Parameter = parameterAst; base.ParameterArgumentType = AstParameterArgumentType.AstPair; base.ParameterSpecified = parameterAst != null; base.ArgumentSpecified = argumentAst != null; base.ParameterName = (parameterAst != null) ? parameterAst.ParameterName : null; base.ParameterText = (parameterAst != null) ? parameterAst.ParameterName : null; base.ArgumentType = (argumentAst != null) ? argumentAst.StaticType : null; this._parameterContainsArgument = false; this._argument = argumentAst; }
internal AstPair(CommandParameterAst parameterAst, CommandParameterAst argumentAst) { if ((parameterAst != null) && (parameterAst.Argument != null)) { throw PSTraceSource.NewArgumentException("parameterAst"); } if ((parameterAst == null) || (argumentAst == null)) { throw PSTraceSource.NewArgumentNullException("argumentAst"); } base.Parameter = parameterAst; base.ParameterArgumentType = AstParameterArgumentType.AstPair; base.ParameterSpecified = true; base.ArgumentSpecified = true; base.ParameterName = parameterAst.ParameterName; base.ParameterText = parameterAst.ParameterName; base.ArgumentType = typeof(string); this._parameterContainsArgument = false; this._argument = argumentAst; this._argumentIsCommandParameterAst = true; }
internal AstPair(CommandParameterAst parameterAst, CommandParameterAst argumentAst) { if ((parameterAst != null) && (parameterAst.Argument != null)) { throw PSTraceSource.NewArgumentException("parameterAst"); } if ((parameterAst == null) || (argumentAst == null)) { throw PSTraceSource.NewArgumentNullException("argumentAst"); } base.Parameter = parameterAst; base.ParameterArgumentType = AstParameterArgumentType.AstPair; base.ParameterSpecified = true; base.ArgumentSpecified = true; base.ParameterName = parameterAst.ParameterName; base.ParameterText = parameterAst.ParameterName; base.ArgumentType = typeof(string); this._parameterContainsArgument = false; this._argument = argumentAst; this._argumentIsCommandParameterAst = true; }
internal ParameterBindingResult(CompiledCommandParameter parameter, CommandElementAst value, Object constantValue) { this.Parameter = new ParameterMetadata(parameter); this.Value = value; this.ConstantValue = constantValue; }
private ExpressionAst MemberInvokeRule(ExpressionAst targetExpr, Token lParen, Token operatorToken, CommandElementAst member) { IScriptExtent scriptExtent; List<ExpressionAst> expressionAsts = new List<ExpressionAst>(); bool flag = false; bool flag1 = this._disableCommaOperator; Token token = null; try { this._disableCommaOperator = true; while (true) { this.SkipNewlines(); ExpressionAst expressionAst = this.ExpressionRule(); if (expressionAst != null) { expressionAsts.Add(expressionAst); this.SkipNewlines(); token = this.NextToken(); if (token.Kind != TokenKind.Comma) { this.UngetToken(token); token = null; break; } } else { if (token == null) { break; } object[] objArray = new object[1]; objArray[0] = TokenKind.Comma.Text(); this.ReportIncompleteInput(Parser.After(token), ParserStrings.MissingExpressionAfterToken, objArray); flag = true; break; } } } finally { this._disableCommaOperator = flag1; } this.SkipNewlines(); Token token1 = this.NextToken(); if (token1.Kind != TokenKind.RParen) { this.UngetToken(token1); if (!flag) { Parser parser = this; if (expressionAsts.Any<ExpressionAst>()) { scriptExtent = Parser.After(expressionAsts.Last<ExpressionAst>()); } else { scriptExtent = Parser.After(lParen); } parser.ReportIncompleteInput(scriptExtent, ParserStrings.MissingEndParenthesisInMethodCall, new object[0]); } token1 = null; } object[] objArray1 = new object[4]; objArray1[0] = token1; objArray1[1] = token; objArray1[2] = expressionAsts.LastOrDefault<ExpressionAst>(); objArray1[3] = lParen; return new InvokeMemberExpressionAst(Parser.ExtentOf(targetExpr, Parser.ExtentFromFirstOf(objArray1)), targetExpr, member, expressionAsts, operatorToken.Kind == TokenKind.ColonColon); }
private static StringConstantExpressionAst MergeMemberAccessExpressions(Ast left, CommandElementAst right) { var extent = MergeExtents(left.Extent, right.Extent); return new StringConstantExpressionAst(extent, extent.Text, StringConstantType.BareWord); }
/// <summary> /// Condition on the parameter that must be satisfied for the error to be raised. /// </summary> /// <param name="CmdAst"></param> /// <param name="CeAst"></param> /// <returns></returns> public override bool ParameterCondition(CommandAst CmdAst, CommandElementAst CeAst) { return CeAst is CommandParameterAst && String.Equals((CeAst as CommandParameterAst).ParameterName, "AsPlainText", StringComparison.OrdinalIgnoreCase); }
public InvokeMemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst method, IEnumerable<ExpressionAst> arguments, bool @static) : base(extent, expression, method, @static) { this.Arguments = arguments.ToReadOnlyCollection(); }
private Expression GetCommandArgumentExpression(CommandElementAst element) { ConstantExpressionAst ast = element as ConstantExpressionAst; if ((ast != null) && LanguagePrimitives.IsNumeric(LanguagePrimitives.GetTypeCode(ast.StaticType))) { string text = ast.Extent.Text; if (!text.Equals(ast.Value.ToString(), StringComparison.Ordinal)) { return Expression.Constant(ParserOps.WrappedNumber(ast.Value, text)); } } Expression expression = this.Compile(element); if (expression.Type.Equals(typeof(object[]))) { return Expression.Call(CachedReflectionInfo.PipelineOps_CheckAutomationNullInCommandArgumentArray, expression); } if ((ast == null) && expression.Type.Equals(typeof(object))) { expression = Expression.Call(CachedReflectionInfo.PipelineOps_CheckAutomationNullInCommandArgument, expression); } return expression; }
CommandParameter ConvertCommandElementToCommandParameter(CommandElementAst commandElement) { if (commandElement is CommandParameterAst) { var commandParameterAst = commandElement as CommandParameterAst; return new CommandParameter(commandParameterAst.ParameterName, commandParameterAst.Argument); } else if (commandElement is StringConstantExpressionAst) { var stringConstantExpressionAst = commandElement as StringConstantExpressionAst; return new CommandParameter(null, stringConstantExpressionAst.Value); } else if (commandElement is ExpressionAst) { return new CommandParameter(null, EvaluateAst(commandElement)); } else throw new NotImplementedException(); }
private string GetCommandName(CommandElementAst commandNameAst, bool isTrustedInput) { var exprAst = commandNameAst as ExpressionAst; string commandName; if (exprAst != null) { var value = GetExpressionValue(exprAst, isTrustedInput); if (value == null) { ScriptBlockToPowerShellChecker.ThrowError( new ScriptBlockToPowerShellNotSupportedException( "CantConvertWithScriptBlockInvocation", null, AutomationExceptions.CantConvertWithScriptBlockInvocation), exprAst); } if (value is CommandInfo) { commandName = ((CommandInfo)value).Name; } else { commandName = value as string; } } else { // If this assertion fires, the command name is determined incorrectly. Diagnostics.Assert(commandNameAst is CommandParameterAst, "Unexpected element not handled correctly."); commandName = commandNameAst.Extent.Text; } if (string.IsNullOrWhiteSpace(commandName)) { // TODO: could use a better error here throw new ScriptBlockToPowerShellNotSupportedException( "CantConvertWithScriptBlockInvocation", null, AutomationExceptions.CantConvertWithScriptBlockInvocation); } return commandName; }
/// <summary> /// Condition on the parameter that must be satisfied for the error to be raised. /// </summary> /// <param name="CmdAst"></param> /// <param name="CeAst"></param> /// <returns></returns> public abstract bool ParameterCondition(CommandAst CmdAst, CommandElementAst CeAst);
public InvokeMemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst method, IEnumerable <ExpressionAst> arguments, bool @static) : base(extent, expression, method, @static) { this.Arguments = arguments.ToReadOnlyCollection(); }
public InvokeMemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst method, IEnumerable <ExpressionAst> arguments, bool @static) : base(extent, expression, method, @static) { if ((arguments != null) && arguments.Any <ExpressionAst>()) { this.Arguments = new ReadOnlyCollection <ExpressionAst>(arguments.ToArray <ExpressionAst>()); base.SetParents((IEnumerable <Ast>) this.Arguments); } }
internal AstPair(CommandParameterAst parameterAst, CommandElementAst argumentAst) { if (parameterAst != null && parameterAst.Argument != null) throw PSTraceSource.NewArgumentException("parameterAst"); if (parameterAst == null || argumentAst == null) throw PSTraceSource.NewArgumentNullException("argumentAst"); Parameter = parameterAst; ParameterArgumentType = AstParameterArgumentType.AstPair; ParameterSpecified = true; ArgumentSpecified = true; ParameterName = parameterAst.ParameterName; ParameterText = parameterAst.ParameterName; ArgumentType = typeof(string); ParameterContainsArgument = false; Argument = argumentAst; ArgumentIsCommandParameterAst = true; }
private Expression GetCommandArgumentExpression(CommandElementAst element) { var constElement = element as ConstantExpressionAst; if (constElement != null && LanguagePrimitives.IsNumeric(LanguagePrimitives.GetTypeCode(constElement.StaticType))) { var commandArgumentText = constElement.Extent.Text; if (!commandArgumentText.Equals(constElement.Value.ToString(), StringComparison.Ordinal)) { // If the ToString on the constant would differ from what the user specified, then wrap the // value so we can recover the actual argument text. return Expression.Constant(ParserOps.WrappedNumber(constElement.Value, commandArgumentText)); } } var result = Compile(element); if (result.Type == typeof(object[])) { result = Expression.Call(CachedReflectionInfo.PipelineOps_CheckAutomationNullInCommandArgumentArray, result); } else if (constElement == null && result.Type == typeof(object)) { result = Expression.Call(CachedReflectionInfo.PipelineOps_CheckAutomationNullInCommandArgument, result); } return result; }
private string GetCommandName(CommandElementAst commandNameAst) { string name; ExpressionAst exprAst = commandNameAst as ExpressionAst; if (exprAst != null) { object expressionValue = this.GetExpressionValue(exprAst); if (expressionValue == null) { ScriptBlockToPowerShellChecker.ThrowError(new ScriptBlockToPowerShellNotSupportedException("CantConvertWithScriptBlockInvocation", null, AutomationExceptions.CantConvertWithScriptBlockInvocation, new object[0]), exprAst); } if (expressionValue is CommandInfo) { name = ((CommandInfo) expressionValue).Name; } else { name = expressionValue as string; } } else { name = commandNameAst.Extent.Text; } if (string.IsNullOrWhiteSpace(name)) { throw new ScriptBlockToPowerShellNotSupportedException("CantConvertWithScriptBlockInvocation", null, AutomationExceptions.CantConvertWithScriptBlockInvocation, new object[0]); } return name; }
/// <summary> /// Creates a StaticBindingException /// </summary> /// <param name="commandElement">The element associated with the exception</param> /// <param name="exception">The parameter binding exception that got raised</param> internal StaticBindingError(CommandElementAst commandElement, ParameterBindingException exception) { this.CommandElement = commandElement; this.BindingException = exception; }
private ExpressionAst MemberInvokeRule(ExpressionAst targetExpr, Token lBracket, Token operatorToken, CommandElementAst member) { //G invocation-expression: target-expression passed as a parameter. lBracket can be '(' or '{'. //G target-expression member-name invoke-param-list //G invoke-param-list: //G '(' invoke-param-paren-list //G script-block IScriptExtent lastExtent = null; List<ExpressionAst> arguments; if (lBracket.Kind == TokenKind.LParen) { arguments = this.InvokeParamParenListRule(lBracket, out lastExtent); } else { arguments = new List<ExpressionAst>(); // handle the construct $x.methodName{2+2} as through it had been written $x.methodName({2+2}) SkipNewlines(); ExpressionAst argument = ScriptBlockExpressionRule(lBracket); arguments.Add(argument); lastExtent = argument.Extent; } return new InvokeMemberExpressionAst(ExtentOf(targetExpr, lastExtent), targetExpr, member, arguments, operatorToken.Kind == TokenKind.ColonColon); }