public static VariableExpressionAst ExtractUsingVariable(UsingExpressionAst usingExpressionAst) { if (usingExpressionAst == null) { throw new ArgumentNullException("usingExpressionAst"); } return(ExtractUsingVariableImpl(usingExpressionAst)); }
public System.Object VisitUsingExpression(System.Management.Automation.Language.UsingExpressionAst usingExpressionAst) { IScriptExtent mappedExtent = MapExtent(usingExpressionAst.Extent); ExpressionAst mappedExpressionAst = _VisitExpression(usingExpressionAst.SubExpression); return(new UsingExpressionAst(mappedExtent, mappedExpressionAst)); }
public static VariableExpressionAst ExtractUsingVariable(UsingExpressionAst usingExpressionAst) { if (usingExpressionAst == null) { throw new ArgumentNullException("usingExpressionAst"); } return ExtractUsingVariableImpl(usingExpressionAst); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { if (usingExpressionAst.RuntimeUsingIndex == -1) { usingExpressionAst.RuntimeUsingIndex = this._runtimeUsingIndex; } this._runtimeUsingIndex++; return(AstVisitAction.Continue); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { ExpressionAst subExpression = usingExpressionAst.SubExpression; ExpressionAst ast2 = this.CheckUsingExpression(subExpression); if (ast2 != null) { this._parser.ReportError(ast2.Extent, ParserStrings.InvalidUsingExpression, new object[0]); } return(AstVisitAction.Continue); }
private static VariableExpressionAst ExtractUsingVariableImpl(ExpressionAst expression) { VariableExpressionAst subExpression; UsingExpressionAst ast = expression as UsingExpressionAst; if (ast != null) { subExpression = ast.SubExpression as VariableExpressionAst; if (subExpression != null) { return(subExpression); } return(ExtractUsingVariableImpl(ast.SubExpression)); } IndexExpressionAst ast3 = expression as IndexExpressionAst; if (ast3 != null) { subExpression = ast3.Target as VariableExpressionAst; if (subExpression != null) { return(subExpression); } return(ExtractUsingVariableImpl(ast3.Target)); } MemberExpressionAst ast4 = expression as MemberExpressionAst; if (ast4 == null) { return(null); } subExpression = ast4.Expression as VariableExpressionAst; if (subExpression != null) { return(subExpression); } return(ExtractUsingVariableImpl(ast4.Expression)); }
/// <summary> /// This method is to get the unique key for a UsingExpressionAst. The key is a base64 /// encoded string based on the text of the UsingExpressionAst. /// /// This method is used when handling a script block that contains $using for Invoke-Command. /// /// When run Invoke-Command targeting a machine that runs PSv3 or above, we pass a dictionary /// to the remote end that contains the key of each UsingExpressionAst and its value. This method /// is used to generate the key. /// </summary> /// <param name="usingAst">A using expression</param> /// <returns>Base64 encoded string as the key of the UsingExpressionAst</returns> internal static string GetUsingExpressionKey(Language.UsingExpressionAst usingAst) { Diagnostics.Assert(usingAst != null, "Caller makes sure the parameter is not null"); // We cannot call ToLowerInvariant unconditionally, because usingAst might // contain IndexExpressionAst in its SubExpression, such as // $using:bar["AAAA"] // and the index "AAAA" might not get us the same value as "aaaa". // // But we do want a unique key to represent the same UsingExpressionAst's as much // as possible, so as to avoid sending redundant key-value's to remote machine. // As a workaround, we call ToLowerInvariant when the SubExpression of usingAst // is a VariableExpressionAst, because: // (1) Variable name is case insensitive; // (2) People use $using to refer to a variable most of the time. string usingAstText = usingAst.ToString(); if (usingAst.SubExpression is Language.VariableExpressionAst) { usingAstText = usingAstText.ToLowerInvariant(); } return(StringToBase64Converter.StringToBase64String(usingAstText)); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { return null; }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { if (usingExpressionAst.RuntimeUsingIndex == -1) { usingExpressionAst.RuntimeUsingIndex = this._runtimeUsingIndex; } this._runtimeUsingIndex++; return AstVisitAction.Continue; }
/// <summary/> public virtual AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) => DefaultVisit(usingExpressionAst);
public static VariableExpressionAst ExtractUsingVariable(UsingExpressionAst usingExpressionAst) { throw new NotImplementedException(usingExpressionAst.ToString()); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { throw new NotImplementedException(); //VisitUsingExpression(usingExpressionAst); }
/// <summary/> public virtual object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { return _decorated.VisitUsingExpression(usingExpressionAst); }
/// <summary> /// Check if the given UsingExpression is in a different scope from the previous UsingExpression that we analyzed. /// </summary> /// <remarks> /// Note that the value of <paramref name="usingExpr"/> is retrieved by calling 'UsingExpressionAstSearcher.FindAllUsingExpressionExceptForWorkflow'. /// So <paramref name="usingExpr"/> is guaranteed not inside a workflow. /// </remarks> /// <param name="usingExpr">The UsingExpression to analyze</param> /// <param name="topLevelParent">The top level Ast, should be either ScriptBlockAst or FunctionDefinitionAst</param> /// <param name="sbClosestToPreviousUsingExpr">The ScriptBlockAst that represents the scope of the previously analyzed UsingExpressions</param> private static bool HasUsingExpressionsInDifferentScopes(UsingExpressionAst usingExpr, Ast topLevelParent, ref ScriptBlockAst sbClosestToPreviousUsingExpr) { Diagnostics.Assert(topLevelParent is ScriptBlockAst || topLevelParent is FunctionDefinitionAst, "the top level parent should be either a ScriptBlockAst or FunctionDefinitionAst"); // Scan up the parents of a UsingExpression to check if it's in a nested function/filter/ScriptBlock Ast current = usingExpr; do { current = current.Parent; var sbAst = current as ScriptBlockAst; if (sbAst != null) { // We find the closest parent ScriptBlockAst of the current UsingExpression, which represents the scope // that the current UsingExpression is in. if (sbClosestToPreviousUsingExpr == null) { // The current UsingExpression is the first one to be analyzed. sbClosestToPreviousUsingExpr = sbAst; return false; } if (sbAst == sbClosestToPreviousUsingExpr) { // The current UsingExpression is in the same scope as the previous UsingExpression we analyzed. return false; } // The current UsingExpression is in a different scope from the previous UsingExpression we analyzed. return true; } var funcAst = current as FunctionDefinitionAst; if (funcAst != null) { // The parent chain of the current UsingExpression reaches a FunctionDefinitionAst, then the UsingExpression // must be in 'Parameters' property of this FunctionDefinitionAst. // In this case, the 'Body' of this FunctionDefinitionAst represents the scope that the UsingExpression is in. if (sbClosestToPreviousUsingExpr == null) { // The current UsingExpression is the first one to be analyzed. sbClosestToPreviousUsingExpr = funcAst.Body; return false; } if (funcAst.Body == sbClosestToPreviousUsingExpr) { // The current UsingExpression is in the same scope as the previous UsingExpression we analyzed. return false; } // The current UsingExpression is in a different scope from the previous UsingExpression we analyzed. return true; } } while (current != topLevelParent); Diagnostics.Assert(false, "Unreachable Code. Top level parent is eitehr ScriptBlockAst or FunctionDefinitionAst, so it should return within the loop for sure."); // I don't think it's reachable, but if it happens, just assume there are UsingExpressions in different scopes. return true; }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { return false; }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { CheckIsConstant(usingExpressionAst.SubExpression, "Caller to verify ast is constant"); return usingExpressionAst.SubExpression.Accept(this); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { return(AstVisitAction.Continue); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst ast) { return this.Check(ast); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { throw new UnexpectedElementException(); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { // The parser will parse anything that could start with a variable when // creating a UsingExpressionAst, but we will only support "simple" // property and array references with no side effects. var exprAst = usingExpressionAst.SubExpression; var badExpr = CheckUsingExpression(exprAst); if (badExpr != null) { _parser.ReportError(badExpr.Extent, () => ParserStrings.InvalidUsingExpression); } return AstVisitAction.Continue; }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { // Using expression is allowed if the sub-expression is allowed. return AstVisitAction.Continue; }
/// <summary> /// Visit UsingExpression /// </summary> /// <param name="usingExpressionAst"></param> /// <returns></returns> public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { // On the local machine, we may have set the index because of a call to ScriptBlockToPowerShell or Invoke-Command. // On the remote machine, the index probably isn't set yet, so we set it here, mostly to avoid another pass // over the ast. We assert below to ensure we're setting to the same value in both the local and remote cases. // Cannot access the RuntimeUsingIndex //if (usingExpressionAst.RuntimeUsingIndex == -1) //{ // usingExpressionAst.RuntimeUsingIndex = _runtimeUsingIndex; //} //System.Diagnostics.Debug.Assert(usingExpressionAst.RuntimeUsingIndex == _runtimeUsingIndex, "Logic error in visiting using expressions."); return AstVisitAction.Continue; }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { // $using:true should be safe - it's silly to write that, but not harmful. return usingExpressionAst.SubExpression.Accept(this); }
/// <summary> /// Visit using expression /// </summary> /// <param name="usingExpressionAst"></param> /// <returns></returns> public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { // The SubExpression is not visited, we treat this expression like it is a constant that is replaced // before the script block is executed return null; }
public object VisitUsingExpression(UsingExpressionAst usingExpression) { return Expression.Call(CachedReflectionInfo.VariableOps_GetUsingValue, this.LocalVariablesParameter, ExpressionCache.Constant(usingExpression.RuntimeUsingIndex), _executionContextParameter); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { // A using expression is always allowed, it simply gets re-written to be a parameter HasUsingExpr = true; // Skip the children - the expression is evaluated before sending to the remote machine, // so it doesn't matter what we might find in the children. return AstVisitAction.SkipChildren; }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst ast) { return(Check(ast)); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { return(usingExpressionAst.SubExpression.Accept(this)); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { // $using:true should be safe - it's silly to write that, but not harmful. _visitCount++; return(usingExpressionAst.SubExpression.Accept(this)); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { ExpressionAst subExpression = usingExpressionAst.SubExpression; ExpressionAst ast2 = this.CheckUsingExpression(subExpression); if (ast2 != null) { this._parser.ReportError(ast2.Extent, ParserStrings.InvalidUsingExpression, new object[0]); } return AstVisitAction.Continue; }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { // $using:true should be constant - it's silly to write that, but not harmful. return(usingExpressionAst.SubExpression.Accept(this)); }
public virtual AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { return AstVisitAction.Continue; }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst ast) { return CheckParent(ast); }
internal static bool IsUsingExpressionInFunction(UsingExpressionAst usingExpr, Ast topLevelParent) { for (Ast ast = usingExpr.Parent; ast != null; ast = ast.Parent) { FunctionDefinitionAst ast2 = ast as FunctionDefinitionAst; if ((ast2 != null) && !ast2.IsWorkflow) { return true; } if (ast == topLevelParent) { break; } } return false; }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { this.HasUsingExpr = true; return AstVisitAction.SkipChildren; }
/// <summary/> public virtual object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { return(null); }
public object VisitUsingExpression(UsingExpressionAst usingExpression) { string usingExprKey = PsUtils.GetUsingExpressionKey(usingExpression); return Expression.Call(CachedReflectionInfo.VariableOps_GetUsingValue, LocalVariablesParameter, Expression.Constant(usingExprKey), ExpressionCache.Constant(usingExpression.RuntimeUsingIndex), _executionContextParameter); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { return usingExpressionAst.SubExpression.Accept(this); }
/// <summary/> public virtual AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { return(AstVisitAction.Continue); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { return AstVisitAction.Continue; }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { CheckIsConstant(usingExpressionAst.SubExpression, "Caller to verify ast is constant"); return(usingExpressionAst.SubExpression.Accept(this)); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { throw new NotImplementedException(); }