public static AssignmentStatementAst As(
this Ast source,
AstType <AssignmentStatementAst> targetType,
ExpressionAst left,
StatementAst right,
TokenKind operatorKind = TokenKind.Equals)
{
return(new AssignmentStatementAst(
source.Extent,
left,
operatorKind,
right,
Empty.Extent(source.Extent)));
}
public object VisitStatementBlock(StatementBlockAst statementBlockAst)
{
if (statementBlockAst.Traps != null)
{
return(false);
}
if (statementBlockAst.Statements.Count > 1)
{
return(false);
}
StatementAst ast = statementBlockAst.Statements.FirstOrDefault <StatementAst>();
return((ast == null) ? ((object)0) : ((object)((bool)ast.Accept(this))));
}
public object VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
_paramBlockExtent = assignmentStatementAst.Left.Extent;
DelegateParameterVisitor.AddVariables(
assignmentStatementAst.Left,
_variables);
var pipeline = assignmentStatementAst.Right as PipelineAst;
if (pipeline == null)
{
return(null);
}
var commandAst = pipeline.PipelineElements[0] as CommandAst;
if (commandAst == null ||
commandAst.GetCommandName() != Strings.DelegateSyntaxCommandName ||
commandAst.CommandElements.Count != 2)
{
return(null);
}
if (commandAst.CommandElements[1] is ScriptBlockExpressionAst sbAst)
{
return(sbAst.ScriptBlock.EndBlock);
}
var expression = commandAst.CommandElements[1] as ExpressionAst;
var statements =
new StatementAst[]
{
new CommandExpressionAst(
expression.Extent,
(ExpressionAst)expression.Copy(),
s_emptyRedirections)
};
var statementBlockAst = new StatementBlockAst(
commandAst.CommandElements[1].Extent,
statements,
s_emptyTraps);
return(new NamedBlockAst(
commandAst.CommandElements[1].Extent,
TokenKind.End,
statementBlockAst,
unnamed: true));
}
/*
* stmt ->
* expr_stmt
| decl_stmt
| if_stmt
| while_stmt
| return_stmt
| block_stmt
| empty_stmt
|
| break_stmt | continue_stmt
*/
public virtual bool ProcessStatement(StatementAst statement)
{
Guard.Against.Null(statement, nameof(statement));
if (statement is BreakStatementAst breakStatement)
{
ProcessBreakStatement(breakStatement);
}
else if (statement is ContinueStatementAst continueStatement)
{
ProcessContinueStatement(continueStatement);
}
else if (statement is ExpressionStatementAst expressionStatement)
{
ProcessExpressionStatement(expressionStatement);
}
else if (statement is DeclarationStatementAst declarationStatement)
{
ProcessDeclarationStatement(declarationStatement);
}
else if (statement is IfStatementAst ifStatement)
{
return(ProcessIfStatement(ifStatement));
}
else if (statement is WhileStatementAst whileStatement)
{
ProcessWhileStatement(whileStatement);
}
else if (statement is ReturnStatementAst returnStatement)
{
ProcessReturnStatement(returnStatement);
return(true);
}
else if (statement is BlockStatementAst blockStatement)
{
return(ProcessBlockStatement(blockStatement));
}
else if (statement is EmptyStatementAst emptyStatement)
{
ProcessEmptyStatement(emptyStatement);
}
else
{
throw new ArgumentException($"Unknown statement type: {statement.GetType()}",
nameof(statement));
}
return(false);
}
public override StatementAst VisitStatement(StatementAst statementAst)
{
if (!(CurrentExpectedKind == SyntaxKind.Any ||
CurrentExpectedKind == SyntaxKind.Statement ||
CurrentExpectedKind == SyntaxKind.Command ||
CurrentExpectedKind == SyntaxKind.Pipeline))
{
return(statementAst);
}
CommandExpressionAst result = CreateLoggingExpression(statementAst);
return(CurrentExpectedKind == SyntaxKind.Pipeline
? (StatementAst)Pipeline(result)
: result);
}
private ExpressionAst CreateLoggingExpressionImpl(
StatementAst evaluation,
IScriptExtent sourceExtent,
Type astType)
{
var color = _colors.Next();
return(Index(
Array(
MaybeCreateStackVar(),
IncrementStack(),
CreateProcessingMessage(sourceExtent, astType, color),
evaluation,
CreateProcessedMessage(sourceExtent.EndScriptPosition, color, astType),
DecrementStack(),
CreateReturnValue()),
Constant(0)));
}
private bool TryCreateScriptBlockExpression(string fileName, IScriptExtent extent, out StatementAst result)
{
ScriptBlockAst ast;
try
{
ast = Parser.ParseFile(fileName, out Token[] tokens, out ParseError[] errors);
public static AssignmentStatementAst Assignment(
ExpressionAst left,
StatementAst right,
TokenKind operatorKind = TokenKind.Equals)
=> Current.Assignment(left, right, operatorKind);
public abstract StatementAst VisitStatement(StatementAst statementAst);
public DropDownEntryInfo(StatementAst body)
{
Body = body;
}
internal static Tuple <List <System.Management.Automation.Language.Token>, List <string> > GetHelpCommentTokens(IParameterMetadataProvider ipmp, Dictionary <Ast, System.Management.Automation.Language.Token[]> scriptBlockTokenCache)
{
int num;
int num2;
int num3;
List <System.Management.Automation.Language.Token> commentBlock;
Ast ast = (Ast)ipmp;
Ast key = ast;
while (key.Parent != null)
{
key = key.Parent;
}
System.Management.Automation.Language.Token[] tokenArray = null;
scriptBlockTokenCache.TryGetValue(key, out tokenArray);
if (tokenArray == null)
{
ParseError[] errorArray;
Parser.ParseInput(key.Extent.Text, out tokenArray, out errorArray);
scriptBlockTokenCache[key] = tokenArray;
}
FunctionDefinitionAst ast3 = ast as FunctionDefinitionAst;
if (ast3 != null)
{
int tokenIndex = num = FirstTokenInExtent(tokenArray, ast.Extent, 0);
commentBlock = GetPrecedingCommentBlock(tokenArray, tokenIndex, 2);
if (IsCommentHelpText(commentBlock))
{
return(Tuple.Create <List <System.Management.Automation.Language.Token>, List <string> >(commentBlock, GetParameterComments(tokenArray, ipmp, num)));
}
num2 = FirstTokenInExtent(tokenArray, ast3.Body.Extent, 0) + 1;
num3 = LastTokenInExtent(tokenArray, ast.Extent, tokenIndex);
}
else if (ast == key)
{
num2 = num = 0;
num3 = tokenArray.Length - 1;
}
else
{
num2 = num = FirstTokenInExtent(tokenArray, ast.Extent, 0) - 1;
num3 = LastTokenInExtent(tokenArray, ast.Extent, num2);
}
do
{
commentBlock = GetCommentBlock(tokenArray, ref num2);
if (commentBlock.Count == 0)
{
goto Label_0195;
}
}while (!IsCommentHelpText(commentBlock));
if (ast == key)
{
NamedBlockAst endBlock = ((ScriptBlockAst)ast).EndBlock;
if ((endBlock == null) || !endBlock.Unnamed)
{
return(Tuple.Create <List <System.Management.Automation.Language.Token>, List <string> >(commentBlock, GetParameterComments(tokenArray, ipmp, num)));
}
StatementAst ast5 = endBlock.Statements.FirstOrDefault <StatementAst>();
if (ast5 is FunctionDefinitionAst)
{
int num5 = ast5.Extent.StartLineNumber - commentBlock.Last <System.Management.Automation.Language.Token>().Extent.EndLineNumber;
if (num5 > 2)
{
return(Tuple.Create <List <System.Management.Automation.Language.Token>, List <string> >(commentBlock, GetParameterComments(tokenArray, ipmp, num)));
}
goto Label_0195;
}
}
return(Tuple.Create <List <System.Management.Automation.Language.Token>, List <string> >(commentBlock, GetParameterComments(tokenArray, ipmp, num)));
Label_0195:
commentBlock = GetPrecedingCommentBlock(tokenArray, num3, tokenArray[num3].Extent.StartLineNumber);
if (IsCommentHelpText(commentBlock))
{
return(Tuple.Create <List <System.Management.Automation.Language.Token>, List <string> >(commentBlock, GetParameterComments(tokenArray, ipmp, num)));
}
return(null);
}
private CommandExpressionAst CreateLoggingExpression(StatementAst source)
{
return(CommandExpression(CreateLoggingExpressionImpl(CreateEvaluation(source), source.Extent, source.GetType())));
}
private StatementAst CreateEvaluation(StatementAst source)
{
return(Assignment(
Variable(TempVariable),
source is CommandBaseAst command ? Pipeline(command) : source));
}
