/// <summary>
/// Initializes a new instance of the FinallyStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="tryStatement">The try-statement that this finally-statement is embedded to.</param>
/// <param name="body">The body of the finally-statement.</param>
internal FinallyStatement(CodeUnitProxy proxy, TryStatement tryStatement, BlockStatement body)
: base(proxy, StatementType.Finally)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(tryStatement, "tryStatement");
Param.AssertNotNull(body, "body");
this.tryStatement.Value = tryStatement;
this.body.Value = body;
}
/// <summary>
/// Initializes a new instance of the CatchStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="tryStatement">The try-statement that this catch-statement is attached to.</param>
/// <param name="classExpression">The inner expression.</param>
/// <param name="body">The body of the catch-statement.</param>
internal CatchStatement(
CodeUnitProxy proxy,
TryStatement tryStatement,
Expression classExpression,
BlockStatement body)
: base(proxy, StatementType.Catch)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(tryStatement, "tryStatement");
Param.Ignore(classExpression);
Param.AssertNotNull(body, "body");
this.tryStatement.Value = tryStatement;
this.catchExpression.Value = classExpression;
this.body.Value = body;
}
/// <summary>
/// Initializes a new instance of the CatchStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="tryStatement">The try-statement that this catch-statement is attached to.</param>
/// <param name="classExpression">The inner expression.</param>
/// <param name="body">The body of the catch-statement.</param>
internal CatchStatement(
CodeUnitProxy proxy,
TryStatement tryStatement,
Expression classExpression,
BlockStatement body)
: base(proxy, StatementType.Catch)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(tryStatement, "tryStatement");
Param.Ignore(classExpression);
Param.AssertNotNull(body, "body");
this.tryStatement.Value = tryStatement;
this.catchExpression.Value = classExpression;
this.body.Value = body;
}
/// <summary>
/// Looks for a finally-statement, and if it is found, parses and returns it.
/// </summary>
/// <param name="parentProxy">Represents the parent item.</param>
/// <param name="tryStatement">The parent try statement.</param>
/// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
/// <returns>Returns the statement.</returns>
private FinallyStatement GetAttachedFinallyStatement(CodeUnitProxy parentProxy, TryStatement tryStatement, bool unsafeCode)
{
Param.AssertNotNull(parentProxy, "parentProxy");
Param.AssertNotNull(tryStatement, "tryStatement");
Param.Ignore(unsafeCode);
FinallyStatement finallyStatement = null;
// Look for a finally keyword.
Symbol symbol = this.PeekNextSymbol();
if (symbol.SymbolType == SymbolType.Finally)
{
this.AdvanceToNextCodeSymbol(parentProxy);
var statementProxy = new CodeUnitProxy(this.document);
// Move up to the finally keyword and add it.
this.GetToken(statementProxy, TokenType.Finally, SymbolType.Finally);
// Get the embedded statement. This must be a block statement.
BlockStatement childStatement = this.GetNextStatement(statementProxy, unsafeCode) as BlockStatement;
if (childStatement == null)
{
throw this.CreateSyntaxException();
}
// Create and return the finally statement.
finallyStatement = new FinallyStatement(statementProxy, tryStatement, childStatement);
parentProxy.Children.Add(finallyStatement);
}
return finallyStatement;
}
/// <summary>
/// Looks for a catch-statement, and if it is found, parses and returns it.
/// </summary>
/// <param name="parentProxy">Represents the parent item.</param>
/// <param name="tryStatement">The parent try statement.</param>
/// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
/// <returns>Returns the statement.</returns>
private CatchStatement GetAttachedCatchStatement(CodeUnitProxy parentProxy, TryStatement tryStatement, bool unsafeCode)
{
Param.AssertNotNull(parentProxy, "parentProxy");
Param.AssertNotNull(tryStatement, "tryStatement");
Param.Ignore(unsafeCode);
CatchStatement catchStatement = null;
// Look for a catch keyword.
Symbol symbol = this.PeekNextSymbol();
if (symbol.SymbolType == SymbolType.Catch)
{
this.AdvanceToNextCodeSymbol(parentProxy);
var statementProxy = new CodeUnitProxy(this.document);
// Move up to the catch keyword and add it.
this.GetToken(statementProxy, TokenType.Catch, SymbolType.Catch);
Expression catchExpression = null;
// Get the opening parenthesis, if there is one.
symbol = this.PeekNextSymbol();
if (symbol.SymbolType == SymbolType.OpenParenthesis)
{
BracketToken openParenthesis = (BracketToken)this.GetToken(statementProxy, TokenType.OpenParenthesis, SymbolType.OpenParenthesis);
// Get the type, if there is one.
symbol = this.PeekNextSymbol();
if (symbol.SymbolType == SymbolType.Other)
{
catchExpression = this.GetNextExpression(statementProxy, ExpressionPrecedence.None, unsafeCode, true, true);
}
// Get the closing parenthesis.
BracketToken closeParenthesis = (BracketToken)this.GetToken(statementProxy, TokenType.CloseParenthesis, SymbolType.CloseParenthesis);
openParenthesis.MatchingBracket = closeParenthesis;
closeParenthesis.MatchingBracket = openParenthesis;
}
// Get the embedded statement. This must be a block statement.
BlockStatement childStatement = this.GetNextStatement(statementProxy, unsafeCode) as BlockStatement;
if (childStatement == null)
{
throw this.CreateSyntaxException();
}
// Create the catch statement.
catchStatement = new CatchStatement(statementProxy, tryStatement, catchExpression, childStatement);
parentProxy.Children.Add(catchStatement);
}
return catchStatement;
}
/// <summary>
/// Reads the next try-statement from the file and returns it.
/// </summary>
/// <param name="parentProxy">Represents the parent item.</param>
/// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
/// <returns>Returns the statement.</returns>
private TryStatement GetTryStatement(CodeUnitProxy parentProxy, bool unsafeCode)
{
Param.AssertNotNull(parentProxy, "parentProxy");
Param.Ignore(unsafeCode);
var statementProxy = new CodeUnitProxy(this.document);
// Move past the try keyword.
this.GetToken(statementProxy, TokenType.Try, SymbolType.Try);
// Get the embedded statement. It must be a block statement.
BlockStatement childStatement = this.GetNextStatement(statementProxy, unsafeCode) as BlockStatement;
if (childStatement == null)
{
throw this.CreateSyntaxException();
}
// Create the try-statement now.
var statement = new TryStatement(statementProxy, childStatement);
parentProxy.Children.Add(statement);
// Get the attached catch statements, if any.
while (true)
{
CatchStatement catchStatement = this.GetAttachedCatchStatement(parentProxy, statement, unsafeCode);
if (catchStatement == null)
{
break;
}
}
// Get the attached finally statement, if any.
this.GetAttachedFinallyStatement(parentProxy, statement, unsafeCode);
// Return the statement.
return statement;
}