/// <summary>
        /// The save.
        /// </summary>
        /// <param name="ifStatement">
        /// The if statement.
        /// </param>
        private void Save(IfStatement ifStatement)
        {
            this.cppWriter.Write("if (");
            @switch(ifStatement.ConditionExpression);
            this.cppWriter.Write(")");

            this.Save(ifStatement.EmbeddedStatement);
        }
        /// <summary>
        /// Reads the next if-statement from the file and returns it.
        /// </summary>
        /// <param name="parentReference">
        /// The parent code unit.
        /// </param>
        /// <param name="unsafeCode">
        /// Indicates whether the code being parsed resides in an unsafe code block.
        /// </param>
        /// <returns>
        /// Returns the statement.
        /// </returns>
        private IfStatement ParseIfStatement(Reference<ICodePart> parentReference, bool unsafeCode)
        {
            Param.AssertNotNull(parentReference, "parentReference");
            Param.Ignore(unsafeCode);

            Reference<ICodePart> statementReference = new Reference<ICodePart>();

            // Move past the if keyword.
            CsToken firstToken = this.GetToken(CsTokenType.If, SymbolType.If, parentReference, statementReference);
            Node<CsToken> firstTokenNode = this.tokens.InsertLast(firstToken);

            // Get the opening parenthesis.
            Bracket openParenthesis = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis, statementReference);
            Node<CsToken> openParenthesisNode = this.tokens.InsertLast(openParenthesis);

            // Get the expression within the parenthesis.
            Expression expression = this.GetNextExpression(ExpressionPrecedence.None, statementReference, unsafeCode);
            if (expression == null)
            {
                throw this.CreateSyntaxException();
            }

            // Get the closing parenthesis.
            Bracket closeParenthesis = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis, statementReference);
            Node<CsToken> closeParenthesisNode = this.tokens.InsertLast(closeParenthesis);

            openParenthesis.MatchingBracketNode = closeParenthesisNode;
            closeParenthesis.MatchingBracketNode = openParenthesisNode;

            // Get the embedded statement.
            Statement childStatement = this.GetNextStatement(statementReference, unsafeCode);
            if (childStatement == null)
            {
                throw new SyntaxException(this.document.SourceCode, firstToken.LineNumber);
            }

            // Create the token list for the statement.
            CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);

            // Create the if-statement.
            IfStatement statement = new IfStatement(partialTokens, expression);
            statement.EmbeddedStatement = childStatement;
            statementReference.Target = statement;

            // Check if there is an else or an else-if attached to this statement.
            ElseStatement attached = this.GetAttachedElseStatement(statementReference, statement, unsafeCode);
            if (attached != null)
            {
                statement.AttachedElseStatement = attached;
            }

            return statement;
        }
        private void CheckStatementCurlyBracketPlacement(CsElement element, Statement statement)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(statement, "statement");

            switch (statement.StatementType)
            {
            case StatementType.Else:

                // Check that there is nothing between the starting else keyword and the opening bracket.
                this.CheckChainedStatementCurlyBracketPlacement(element, statement);
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);

                // Check that there is nothing between the closing bracket and the else keyword of the attached else statement.
                ElseStatement elseStatement = (ElseStatement)statement;
                if (elseStatement.AttachedElseStatement != null)
                {
                    this.CheckTrailingStatementCurlyBracketPlacement(element, statement);
                }

                break;

            case StatementType.Catch:
            case StatementType.Finally:

                // Check that there is nothing between the starting catch or finally keyword and the opening bracket.
                this.CheckChainedStatementCurlyBracketPlacement(element, statement);
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);
                break;

            case StatementType.If:
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);

                // Check that there is nothing between the closing bracket and the else keyword of the attached else statement.
                IfStatement ifStatement = (IfStatement)statement;
                if (ifStatement.AttachedElseStatement != null)
                {
                    this.CheckTrailingStatementCurlyBracketPlacement(element, statement);
                }

                break;

            case StatementType.Try:

                // Check that there is nothing between the starting try keyword and the opening bracket.
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);

                TryStatement tryStatement = (TryStatement)statement;
                if (tryStatement.FinallyStatement != null || (tryStatement.CatchStatements != null && tryStatement.CatchStatements.Count > 0))
                {
                    // There is something attached to the end of this try statement. Check that there is nothing between
                    // the closing bracket of the try statement and the start of the attached statement.
                    this.CheckTrailingStatementCurlyBracketPlacement(element, tryStatement);
                }

                if (tryStatement.CatchStatements != null && tryStatement.CatchStatements.Count > 0)
                {
                    CatchStatement[] catchStatementArray = new CatchStatement[tryStatement.CatchStatements.Count];
                    tryStatement.CatchStatements.CopyTo(catchStatementArray, 0);

                    for (int i = 0; i < catchStatementArray.Length; ++i)
                    {
                        if (catchStatementArray.Length > i + 1 || tryStatement.FinallyStatement != null)
                        {
                            // There is something attached to the end of this catch statement, either another catch or a finally.
                            // Check that there is nothing between the closing bracket of this catch statement and the start of the attached
                            // statement.
                            this.CheckTrailingStatementCurlyBracketPlacement(element, catchStatementArray[i]);
                        }
                    }
                }

                break;

            case StatementType.Checked:
            case StatementType.Fixed:
            case StatementType.For:
            case StatementType.Foreach:
            case StatementType.Lock:
            case StatementType.Switch:
            case StatementType.Unchecked:
            case StatementType.Unsafe:
            case StatementType.Using:
            case StatementType.While:

                // Check that there is nothing between the starting keyword and the opening bracket.
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);
                break;

            case StatementType.DoWhile:
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);
                this.CheckTrailingStatementCurlyBracketPlacement(element, statement);
                break;

            default:
                break;
            }
        }