public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
// This can be used for a denial of service
// Write-Output (((((("AAAAAAAAAAAAAAAAAAAAAA"*2)*2)*2)*2)*2)*2)
// Keep on going with that pattern, and we're generating gigabytes of strings.
return(false);
}
public void ConvertBinaryExpression(BinaryExpressionAst binaryExpression)
{
var bExp = BuildExpression(binaryExpression);
var l = Expression.Lambda <Func <T, bool> >(bExp, _p);
_inputArray = _inputArray.Where(l);
}
private bool IncorrectComparisonWithNull(BinaryExpressionAst binExpressionAst, Ast ast)
{
if ((binExpressionAst.Operator.Equals(TokenKind.Equals) || binExpressionAst.Operator.Equals(TokenKind.Ceq) ||
binExpressionAst.Operator.Equals(TokenKind.Cne) || binExpressionAst.Operator.Equals(TokenKind.Ine) || binExpressionAst.Operator.Equals(TokenKind.Ieq)) &&
binExpressionAst.Right.Extent.Text.Equals("$null", StringComparison.OrdinalIgnoreCase))
{
if (binExpressionAst.Left.StaticType.IsArray)
{
return(true);
}
else if (binExpressionAst.Left is VariableExpressionAst)
{
// ignores if the variable is a special variable
if (!Helper.Instance.HasSpecialVars((binExpressionAst.Left as VariableExpressionAst).VariablePath.UserPath))
{
Type lhsType = Helper.Instance.GetTypeFromAnalysis(binExpressionAst.Left as VariableExpressionAst, ast);
if (lhsType == null)
{
return(true);
}
else if (lhsType.IsArray || lhsType == typeof(object) || lhsType == typeof(Undetermined) || lhsType == typeof(Unreached))
{
return(true);
}
}
}
else if (binExpressionAst.Left.StaticType == typeof(object))
{
return(true);
}
}
return(false);
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
// This can be used for a denial of service
// Write-Output (((((("AAAAAAAAAAAAAAAAAAAAAA"*2)*2)*2)*2)*2)*2)
// Keep on going with that pattern, and we're generating gigabytes of strings.
throw PSTraceSource.NewArgumentException("ast");
}
public object ConvertBinaryExpression(BinaryExpressionAst binaryExpression, object[] Arguments)
{
arguments = Arguments;
var bExp = BuildExpression(binaryExpression);
return(Expression.Lambda <Func <T, bool> >(bExp, _p));
}
protected override void BeginProcessing()
{
var expressions = Expression.Ast.FindAll(p => p.GetType().Name.Equals("BinaryExpressionAst"), true);
if (expressions.Count() == 0)
{
throw new Exception("Error parsing expression - No binary expressions found!");
}
_binaryExpressionAst = (BinaryExpressionAst)expressions.First();
var qu = ((IEnumerable)InputArray.BaseObject).AsQueryable();
var arguments = InputArray.BaseObject.GetType().GetTypeInfo().GenericTypeArguments;
if (arguments.Count() == 0)
{
arguments = qu.GetType().GetTypeInfo().GenericTypeArguments;
}
if (arguments.Count() > 0)
{
var genericType = arguments[0];
var poshBinaryType = typeof(PoshBinaryConverter <>);
var constructedPoshBinaryType = poshBinaryType.MakeGenericType(genericType);
_binaryConverter = (IPoshBinaryConverter)Activator.CreateInstance(constructedPoshBinaryType, new object[] { qu, SessionState });
}
else
{
throw new Exception("Error parsing InputArray - Must be a strongly typed collection like generic collections. See more here: https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic?view=dotnet-plat-ext-3.1");
}
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
var newLeft = VisitElement(binaryExpressionAst.Left);
var newRight = VisitElement(binaryExpressionAst.Right);
return(new BinaryExpressionAst(binaryExpressionAst.Extent, newLeft, binaryExpressionAst.Operator, newRight,
binaryExpressionAst.ErrorPosition));
}
public void LogicalOperator()
{
BinaryExpressionAst binaryExpressionAst = ParseStatement("($true) -or ($false)")
.PipelineElements[0]
.Expression;
Assert.AreEqual(TokenKind.Or, binaryExpressionAst.Operator);
}
public override Unit VisitBinaryExpression(BinaryExpressionAst expr)
{
var binaryOperationGen = new BinaryExpressionILGenerator(expr, this);
binaryOperationGen.GenerateCode(code);
return(Unit.Create());
}
public void TwoStrings()
{
BinaryExpressionAst expressionAst = ParseStatement(@"""a"" + ""b""")
.PipelineElements[0]
.Expression
;
Assert.AreEqual(TokenKind.Plus, expressionAst.Operator);
}
public virtual ExpressionAst VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return(new BinaryExpressionAst(
binaryExpressionAst.Extent,
binaryExpressionAst.Left.Rewrite(this, SyntaxKind.Expression),
binaryExpressionAst.Operator,
binaryExpressionAst.Right.Rewrite(this, SyntaxKind.Expression),
binaryExpressionAst.ErrorPosition));
}
public void ArrayRangeTest()
{
BinaryExpressionAst result = ParseStatement("1..10")
.PipelineElements[0]
.Expression;
ConstantExpressionAst left = (ConstantExpressionAst)result.Left;
ConstantExpressionAst right = (ConstantExpressionAst)result.Right;
Assert.AreEqual(1, left.Value);
Assert.AreEqual(10, right.Value);
}
public static BinaryExpressionAst Update(
this BinaryExpressionAst ast,
ExpressionAst left = null,
TokenKind? @operator = null,
ExpressionAst right = null)
{
return(new BinaryExpressionAst(
ast.Extent,
left?.Clone() ?? ast.Left.Clone(),
@operator ?? ast.Operator,
right?.Clone() ?? ast.Right.Clone(),
ast.ErrorPosition));
}
public override bool VisitBinaryExpression(BinaryExpressionAst expr)
{
BinaryExpressionAst binExpr = _other as BinaryExpressionAst;
if (binExpr == null)
{
return(false);
}
return(IsEqualNodes(binExpr.LeftExp, expr.LeftExp) &&
IsEqualNodes(binExpr.RightExp, expr.RightExp) &&
(binExpr.Operator == expr.Operator));
}
private IEnumerable <CorrectionExtent> GetCorrectionExtent(BinaryExpressionAst binaryExpressionAst)
{
var correction = new CorrectionExtent(
binaryExpressionAst.Extent.StartLineNumber,
binaryExpressionAst.Extent.EndLineNumber,
binaryExpressionAst.Extent.StartColumnNumber,
binaryExpressionAst.Extent.EndColumnNumber,
$"{binaryExpressionAst.Right.Extent.Text} {binaryExpressionAst.ErrorPosition.Text} {binaryExpressionAst.Left.Extent.Text}",
binaryExpressionAst.Extent.File,
Strings.PossibleIncorrectComparisonWithNullSuggesteCorrectionDescription
);
yield return(correction);
}
private Expression BuildExpression(BinaryExpressionAst ast)
{
var leftExpression = GetExpression(ast.Left);
var rightExpression = GetExpression(ast.Right);
switch (ast.Operator)
{
case TokenKind.Ieq:
if (leftExpression.Type == typeof(string) && rightExpression.Type == typeof(string))
{
var mi = typeof(String).GetMethods().Where(p => p.GetParameters().Count() == 3 && p.Name == "Equals").FirstOrDefault();
var ordinalCase = Expression.Constant(StringComparison.OrdinalIgnoreCase);
return(Expression.Call(mi, new Expression[] { leftExpression, rightExpression, ordinalCase }));
}
return(Expression.Equal(leftExpression, rightExpression));
case TokenKind.Ceq:
return(Expression.Equal(leftExpression, rightExpression));
case TokenKind.And:
return(Expression.And(leftExpression, rightExpression));
case TokenKind.Or:
return(Expression.Or(leftExpression, rightExpression));
case TokenKind.Ccontains:
case TokenKind.Icontains:
var method = leftExpression.Type.GetMethods().Where(p => p.Name == "Contains" && p.GetParameters().Count() == 1).FirstOrDefault();
return(Expression.Call(leftExpression, method, rightExpression));
case TokenKind.Ige:
case TokenKind.Cge:
return(Expression.GreaterThanOrEqual(leftExpression, rightExpression));
case TokenKind.Igt:
case TokenKind.Cgt:
return(Expression.GreaterThan(leftExpression, rightExpression));
case TokenKind.Ilt:
case TokenKind.Clt:
return(Expression.LessThan(leftExpression, rightExpression));
case TokenKind.Ile:
case TokenKind.Cle:
return(Expression.LessThanOrEqual(leftExpression, rightExpression));
default:
return(null);
}
}
protected override void BeginProcessing()
{
var poshBinaryType = typeof(PoshBinaryConverter <>);
var constructedPoshBinaryType = poshBinaryType.MakeGenericType(FuncType);
_binaryConverter = (IPoshBinaryConverter)Activator.CreateInstance(constructedPoshBinaryType, new object[] { SessionState });
var expressions = Expression.Ast.FindAll(p => p.GetType().Name.Equals("BinaryExpressionAst"), true);
if (expressions.Count() == 0)
{
throw new Exception("Error parsing expression - No binary expressions found!");
}
_binaryExpressionAst = (BinaryExpressionAst)expressions.First();
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
var left = VisitSyntaxNode(binaryExpressionAst.Left);
var @operator = BinaryOperator.Unknown;
if (_operatorMap.ContainsKey(binaryExpressionAst.Operator))
{
@operator = _operatorMap[binaryExpressionAst.Operator];
}
var right = VisitSyntaxNode(binaryExpressionAst.Right);
_currentNode = new BinaryExpression(left, @operator, right);
return(AstVisitAction.SkipChildren);
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
var(tokenDescription, helpQuery) = Helpers.TokenExplainer(binaryExpressionAst.Operator);
helpQuery ??= "about_operators";
var helpResult = HelpTableQuery(helpQuery);
explanations.Add(
new Explanation()
{
CommandName = "Operator",
HelpResult = helpResult,
Description = $"{tokenDescription} This works from left to right, so targeting '{binaryExpressionAst.Right.Extent.Text}'",
TextToHighlight = binaryExpressionAst.Operator.Text()
}.AddDefaults(binaryExpressionAst, explanations));
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
if (!TargetsNonPS7())
{
return(AstVisitAction.Continue);
}
if (binaryExpressionAst.Operator == TokenKind.QuestionQuestion)
{
AddDiagnostic(
binaryExpressionAst,
"null-coalescing operator",
"$x ?? $y",
"3,4,5,6");
}
return(AstVisitAction.Continue);
}
public override bool VisitBinaryExpression(BinaryExpressionAst expr)
{
expr.LeftExp.Accept(this);
TigerType leftType = expr.LeftExp.ReturnType;
expr.RightExp.Accept(this);
TigerType rightType = expr.RightExp.ReturnType;
if (CheckOperator(leftType, rightType, expr.Operator, out var tt))
{
expr.ReturnType = tt;
return(true);
}
_errorListener.Add(
new AnalysisError(string.Format(AnalysisError.LoadMessage("SupportOp"), expr.Operator, leftType, rightType), expr.Line,
expr.Columns));
expr.ReturnType = TigerType.GetType <ErrorType>();
return(false);
}
public static void MeasureUnsafeEscaping(string ScriptBlock)
{
Token[] token;
ParseError[] error;
ScriptBlockAst ScriptBlockAst = Parser.ParseInput(ScriptBlock, out token, out error);
Func <Ast, bool> predicate = delegate(Ast ast)
{
var leftVariable = new VariableExpressionAst(ast.Extent, "herp", splatted: false);
var rightVariable = new VariableExpressionAst(ast.Extent, "derp", splatted: false);
var targetAst = new BinaryExpressionAst(ast.Extent, leftVariable, TokenKind.Ieq, rightVariable, ast.Extent);
if (targetAst != null)
{
if (targetAst.Operator.In(false, new List <string> {
"replace"
}) && targetAst.Right.Extent.Text.In(false, new List <string> {
"`", "'"
}))
{
return(true);
}
}
return(false);
};
var foundNode = ScriptBlockAst.Find(predicate, true);
if (foundNode != null)
{
Console.WriteLine("[+] Possible injection vulnerability found");
Console.WriteLine(@"Possible unsafe use of input escaping. Variables may be used directly for dynamic parameter arguments, splatting can be used for dynamic parameter names,
and the invocation operator can be used for dynamic command names. If content escaping is truly needed, PowerShell has several valid quote characters,
so the [System.Management.Automation.Language.CodeGeneration]::Escape* should be used instead
RuleName = InjectionRisk.UnsafeEscaping
Severity = Warning");
}
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return(!((bool)binaryExpressionAst.Left.Accept(this)) ? ((object)0) : ((object)((bool)binaryExpressionAst.Right.Accept(this))));
}
/// <summary/> public virtual AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst) => DefaultVisit(binaryExpressionAst);
public abstract T VisitBinaryExpression(BinaryExpressionAst expr);
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst) => null;
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
Console.WriteLine("Visited an BinaryExpressionAst.");
return(binaryExpressionAst);
}
public override object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
VisitElement(binaryExpressionAst.Left);
switch (binaryExpressionAst.Operator)
{
case TokenKind.Dot:
script_.Write(".");
break;
case TokenKind.DotDot:
script_.Write("..");
break;
case TokenKind.Exclaim:
script_.Write("!");
break;
case TokenKind.Ilt:
script_.Write("-lt");
break;
case TokenKind.Ile:
script_.Write("-le");
break;
case TokenKind.Ieq:
script_.Write("-eq");
break;
case TokenKind.Ine:
script_.Write("-ne");
break;
case TokenKind.Ige:
script_.Write("-ge");
break;
case TokenKind.Igt:
script_.Write("-gt");
break;
case TokenKind.Format:
script_.Write("-f");
break;
case TokenKind.And:
case TokenKind.Or:
case TokenKind.Xor:
case TokenKind.Not:
case TokenKind.Band:
case TokenKind.Bor:
case TokenKind.Bnot:
case TokenKind.Bxor:
case TokenKind.Is:
case TokenKind.IsNot:
script_.Write("-" + binaryExpressionAst.Operator.ToString().ToLower());
break;
case TokenKind.Ceq:
case TokenKind.Cge:
case TokenKind.Cin:
case TokenKind.Cle:
case TokenKind.Clt:
case TokenKind.Cmatch:
case TokenKind.Cne:
case TokenKind.Cnotcontains:
case TokenKind.Cnotin:
case TokenKind.Cnotlike:
case TokenKind.Cnotmatch:
case TokenKind.Ilike:
case TokenKind.Inotlike:
case TokenKind.Imatch:
case TokenKind.Inotmatch:
script_.Write("-" + binaryExpressionAst.Operator.ToString().Substring(1).ToLower());
break;
case TokenKind.Plus:
script_.Write("+");
break;
case TokenKind.Minus:
script_.Write("-");
break;
case TokenKind.Multiply:
script_.Write("*");
break;
case TokenKind.Divide:
script_.Write("/");
break;
case TokenKind.Module:
script_.Write("%");
break;
default:
throw new Exception("Binary token not supported");
}
VisitElement(binaryExpressionAst.Right);
return(binaryExpressionAst);
}
private List <CompletionResult> GetResultForIdentifier(CompletionContext completionContext, ref int replacementIndex, ref int replacementLength, bool isQuotedString)
{
Token tokenAtCursor = completionContext.TokenAtCursor;
Ast lastAst = completionContext.RelatedAsts.Last <Ast>();
List <CompletionResult> source = null;
completionContext.WordToComplete = tokenAtCursor.Text;
StringConstantExpressionAst ast2 = lastAst as StringConstantExpressionAst;
if ((ast2 != null) && ast2.Value.Equals("$", StringComparison.Ordinal))
{
completionContext.WordToComplete = "";
return(CompletionCompleters.CompleteVariable(completionContext));
}
if ((tokenAtCursor.TokenFlags & TokenFlags.CommandName) != TokenFlags.None)
{
if ((completionContext.RelatedAsts.Count > 0) && (completionContext.RelatedAsts[0] is ScriptBlockAst))
{
Ast lastAstAtCursor = null;
InternalScriptPosition position = (InternalScriptPosition)this._cursorPosition;
int offset = position.Offset - tokenAtCursor.Text.Length;
if (offset >= 0)
{
InternalScriptPosition cursorPosition = position.CloneWithNewOffset(offset);
ScriptBlockAst scriptBlockAst = (ScriptBlockAst)completionContext.RelatedAsts[0];
lastAstAtCursor = GetLastAstAtCursor(scriptBlockAst, cursorPosition);
}
if (((lastAstAtCursor != null) && (lastAstAtCursor.Extent.EndLineNumber == tokenAtCursor.Extent.StartLineNumber)) && (lastAstAtCursor.Extent.EndColumnNumber == tokenAtCursor.Extent.StartColumnNumber))
{
if (tokenAtCursor.Text.IndexOfAny(new char[] { '\\', '/' }) == 0)
{
string str = CompletionCompleters.ConcatenateStringPathArguments(lastAstAtCursor as CommandElementAst, tokenAtCursor.Text, completionContext);
if (str != null)
{
completionContext.WordToComplete = str;
source = new List <CompletionResult>(CompletionCompleters.CompleteFilename(completionContext));
if (source.Count > 0)
{
replacementIndex = lastAstAtCursor.Extent.StartScriptPosition.Offset;
replacementLength += lastAstAtCursor.Extent.Text.Length;
}
return(source);
}
VariableExpressionAst variableAst = lastAstAtCursor as VariableExpressionAst;
string str2 = (variableAst != null) ? CompletionCompleters.CombineVariableWithPartialPath(variableAst, tokenAtCursor.Text, completionContext.ExecutionContext) : null;
if (str2 == null)
{
return(source);
}
completionContext.WordToComplete = str2;
replacementIndex = lastAstAtCursor.Extent.StartScriptPosition.Offset;
replacementLength += lastAstAtCursor.Extent.Text.Length;
completionContext.ReplacementIndex = replacementIndex;
completionContext.ReplacementLength = replacementLength;
}
else if (!(lastAstAtCursor is ErrorExpressionAst) || !(lastAstAtCursor.Parent is IndexExpressionAst))
{
return(source);
}
}
}
if (!isQuotedString)
{
StringExpandableToken token2 = tokenAtCursor as StringExpandableToken;
if (((token2 != null) && (token2.NestedTokens != null)) && (ast2 != null))
{
try
{
string expandedString = null;
ExpandableStringExpressionAst expandableStringAst = new ExpandableStringExpressionAst(ast2.Extent, ast2.Value, StringConstantType.BareWord);
if (CompletionCompleters.IsPathSafelyExpandable(expandableStringAst, string.Empty, completionContext.ExecutionContext, out expandedString))
{
completionContext.WordToComplete = expandedString;
}
else
{
return(source);
}
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
return(source);
}
}
source = CompleteFileNameAsCommand(completionContext);
List <CompletionResult> collection = CompletionCompleters.CompleteCommand(completionContext);
if ((collection != null) && (collection.Count > 0))
{
source.AddRange(collection);
}
}
return(source);
}
if (((tokenAtCursor.Text.Length == 1) && tokenAtCursor.Text[0].IsDash()) && (lastAst.Parent is CommandAst))
{
if (isQuotedString)
{
return(source);
}
return(CompletionCompleters.CompleteCommandParameter(completionContext));
}
TokenKind unknown = TokenKind.Unknown;
bool flag = lastAst.Parent is MemberExpressionAst;
bool @static = flag ? ((MemberExpressionAst)lastAst.Parent).Static : false;
bool flag3 = false;
if (!flag)
{
if (tokenAtCursor.Text.Equals(TokenKind.Dot.Text(), StringComparison.Ordinal))
{
unknown = TokenKind.Dot;
flag = true;
}
else if (tokenAtCursor.Text.Equals(TokenKind.ColonColon.Text(), StringComparison.Ordinal))
{
unknown = TokenKind.ColonColon;
flag = true;
}
else if (tokenAtCursor.Kind.Equals(TokenKind.Multiply) && (lastAst is BinaryExpressionAst))
{
BinaryExpressionAst item = (BinaryExpressionAst)lastAst;
MemberExpressionAst left = item.Left as MemberExpressionAst;
IScriptExtent errorPosition = item.ErrorPosition;
if (((left != null) && (item.Operator == TokenKind.Multiply)) && (errorPosition.StartOffset == left.Member.Extent.EndOffset))
{
@static = left.Static;
unknown = @static ? TokenKind.ColonColon : TokenKind.Dot;
flag = true;
flag3 = true;
completionContext.RelatedAsts.Remove(item);
completionContext.RelatedAsts.Add(left);
StringConstantExpressionAst member = left.Member as StringConstantExpressionAst;
if (member != null)
{
replacementIndex = member.Extent.StartScriptPosition.Offset;
replacementLength += member.Extent.Text.Length;
}
}
}
}
if (flag)
{
source = CompletionCompleters.CompleteMember(completionContext, @static || (unknown == TokenKind.ColonColon));
if (source.Any <CompletionResult>())
{
if (!flag3 && (unknown != TokenKind.Unknown))
{
replacementIndex += tokenAtCursor.Text.Length;
replacementLength = 0;
}
return(source);
}
}
if (lastAst.Parent is HashtableAst)
{
source = CompletionCompleters.CompleteHashtableKey(completionContext, (HashtableAst)lastAst.Parent);
if ((source != null) && source.Any <CompletionResult>())
{
return(source);
}
}
if (!isQuotedString)
{
bool flag4 = false;
if ((lastAst.Parent is FileRedirectionAst) || CompleteAgainstSwitchFile(lastAst, completionContext.TokenBeforeCursor))
{
string str4 = CompletionCompleters.ConcatenateStringPathArguments(lastAst as CommandElementAst, string.Empty, completionContext);
if (str4 != null)
{
flag4 = true;
completionContext.WordToComplete = str4;
}
}
else if (tokenAtCursor.Text.IndexOfAny(new char[] { '\\', '/' }) == 0)
{
CommandBaseAst parent = lastAst.Parent as CommandBaseAst;
if ((parent != null) && parent.Redirections.Any <RedirectionAst>())
{
FileRedirectionAst ast11 = parent.Redirections[0] as FileRedirectionAst;
if (((ast11 != null) && (ast11.Extent.EndLineNumber == lastAst.Extent.StartLineNumber)) && (ast11.Extent.EndColumnNumber == lastAst.Extent.StartColumnNumber))
{
string str5 = CompletionCompleters.ConcatenateStringPathArguments(ast11.Location, tokenAtCursor.Text, completionContext);
if (str5 != null)
{
flag4 = true;
completionContext.WordToComplete = str5;
replacementIndex = ast11.Location.Extent.StartScriptPosition.Offset;
replacementLength += ast11.Location.Extent.EndScriptPosition.Offset - replacementIndex;
completionContext.ReplacementIndex = replacementIndex;
completionContext.ReplacementLength = replacementLength;
}
}
}
}
if (flag4)
{
return(new List <CompletionResult>(CompletionCompleters.CompleteFilename(completionContext)));
}
string str6 = CompletionCompleters.ConcatenateStringPathArguments(lastAst as CommandElementAst, string.Empty, completionContext);
if (str6 != null)
{
completionContext.WordToComplete = str6;
}
source = CompletionCompleters.CompleteCommandArgument(completionContext);
replacementIndex = completionContext.ReplacementIndex;
replacementLength = completionContext.ReplacementLength;
}
return(source);
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
Console.WriteLine("Visited an BinaryExpressionAst.");
Console.WriteLine(" " + binaryExpressionAst.ToString().Replace(Environment.NewLine, Environment.NewLine + " "));
return(AstVisitAction.Continue);
}
