* Copyright (c) 2007 BUSINESS OBJECTS SOFTWARE LIMITED

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

*     * Redistributions of source code must retain the above copyright notice,

*       this list of conditions and the following disclaimer.

*

*     * Redistributions in binary form must reproduce the above copyright

*       notice, this list of conditions and the following disclaimer in the

*       documentation and/or other materials provided with the distribution.

*

*     * Neither the name of Business Objects nor the names of its contributors

*       may be used to endorse or promote products derived from this software

*       without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

* POSSIBILITY OF SUCH DAMAGE.

*/

/*

* JavaSourceGenerator.java

* Creation date: Sep 11, 2003.

* By: Edward Lam

*/

* A class to generate Java source code given an object representation.

* @author Edward Lam

*/

    /** The length of an indent. */

    private static final int INDENT_LENGTH = 4;

    /** Line separator. */

    private static final String EOL = System.getProperty("line.separator");

    /**

     * Constructor for a JavaSourceGenerator

     */

    JavaSourceGenerator() {

    }

    /**

     * Holds class names used, etc.

     * TODOEL: manage namespace collisions.

     * @author Edward Lam

     */

    static class GenerationContext {

        private final JavaTypeName classTypeName;

        private Map<String, JavaTypeName> unqualifiedNameToTypeNameMap = new TreeMap<String, JavaTypeName>();       // TODOEL: resolve conflicts.

        /**

         * Constructor for a GenerationContext

         * @param classTypeName

         */

        GenerationContext(JavaTypeName classTypeName) {

            this.classTypeName = classTypeName;

        }

        /**

         * Get the name that can be used in java source for a given type (class).

         * @param typeName

         * @return String

         */

        String getSourceName(JavaTypeName typeName) {

            // We can declare an import and return the short class name if:

            // 1) There isn't another class with the same name imported from another module.

            // 2) The imported class doesn't have the same name as the class we are creating.

            switch (typeName.getTag()) {

                case JavaTypeName.VOID_TAG:

                case JavaTypeName.BOOLEAN_TAG:

                case JavaTypeName.BYTE_TAG:

                case JavaTypeName.SHORT_TAG:

                case JavaTypeName.CHAR_TAG:

                case JavaTypeName.INT_TAG:

                case JavaTypeName.LONG_TAG:

                case JavaTypeName.DOUBLE_TAG:

                case JavaTypeName.FLOAT_TAG:

                    return typeName.getName();

                case JavaTypeName.OBJECT_TAG:

                {

                    JavaTypeName.Reference.Object referenceType = (JavaTypeName.Reference.Object)typeName;

                    // Same type name as this class.

                    if (typeName.equals(classTypeName)) {

                        return referenceType.getBaseName();

                    }

                    // if this type is in java.lang we will need to fully qualify it.

                    // This prevents conflicts with other classes with the same name

                    // ex. mypackage.String

                    if (typeName.getPackageName().equals("java.lang")) {

                        return referenceType.getFullJavaSourceName();

                    }

                    JavaTypeName.Reference.Object classType = (JavaTypeName.Reference.Object)classTypeName;

                    String importName = referenceType.getImportName();

                    // Same enclosing class (ie. for nested classes..).

                    if (importName.equals(classType.getImportName())) {

                        return referenceType.getBaseName();

                    }

                    String objectPackageName = referenceType.getPackageName();

                    String unqualifiedName = referenceType.getUnqualifiedJavaSourceName();

                    // Same unqualified name as this class, different module.

                    if (unqualifiedName.equals(classType.getUnqualifiedJavaSourceName())) {

                        return referenceType.getFullJavaSourceName();

                    }

                    // Inner class, where outer class has same name as this class.

                    String tempName = unqualifiedName;

                    int index = tempName.indexOf (".");

                    while (index >= 0) {

                        String tempUnqualifiedName = tempName.substring(0, index);

                        // Same unqualified name as this class, different module.

                        if (tempUnqualifiedName.equals(classType.getUnqualifiedJavaSourceName())) {

                            return referenceType.getFullJavaSourceName();

                        }

                        tempName = tempName.substring(index + 1);

                        index = tempName.indexOf (".");

                    }

                    // We want to key the unqualified name to typename map off of the containing class name

                    // in cases where we are dealing with an inner class.

                    int dotIndex = unqualifiedName.indexOf (".");

                    String lookupName = (dotIndex != -1) ? unqualifiedName.substring(0, dotIndex): unqualifiedName;

                    JavaTypeName existingTypeName = unqualifiedNameToTypeNameMap.get(lookupName);

                    if (existingTypeName == null) {

                        unqualifiedNameToTypeNameMap.put(lookupName, typeName);

                        return referenceType.getUnqualifiedJavaSourceName();

                    }

                    if (objectPackageName.equals(existingTypeName.getPackageName())) {

                        // There is already a match for this type, or the containing type if this is

                        // an inner class, simply return the unqualifiedName

                        return unqualifiedName;

                    }

                    // There is a match on the unqualifiedName but it is not the same type.

                    return referenceType.getFullJavaSourceName();

                }

                case JavaTypeName.ARRAY_TAG:

                {

                    JavaTypeName.Reference.Array arrayType = (JavaTypeName.Reference.Array)typeName;

                    int nDimensions = arrayType.getNDimensions();

                    JavaTypeName elementType = arrayType.getElementType();

                    // Get the source for the element type, and append "[]" for each dimension.

                    StringBuilder sb = new StringBuilder(getSourceName(elementType));

                    for (int i = 0; i < nDimensions; i++) {

                        sb.append("[]");

                    }

                    return sb.toString();

                }

                default:

                {

                    throw new NullPointerException("Unrecognized class: " + typeName.getName());

                }

            }

        }

        /**

         * Get the type names for which unqualified names were output in source.

         * @return (List of JavaTypeName)

         */

        List<JavaTypeName> getTypeNames() {

            return new ArrayList<JavaTypeName>(unqualifiedNameToTypeNameMap.values());

        }

    }

    /**

     * Emit import statements.

     * @param leccPackageName

     * @param topLevelClassName

     * @param context

     * @return String

     */

    private static String genS_Imports(String leccPackageName, String topLevelClassName, GenerationContext context) {

        // Get the sorted set of import names.

        Set<String> importNameSet = new TreeSet<String>();

        for (final JavaTypeName typeName : context.getTypeNames()) {

            String packageName = typeName.getPackageName();

            if (packageName.equals("") || packageName.equals("java.lang") || packageName.equals(leccPackageName)) {

                continue;

            }

            // Check to see if the class is an inner class of the current class.

            if (packageName.equals(topLevelClassName)) {

                continue;

            }

            importNameSet.add(((JavaTypeName.Reference.Object)typeName).getImportName());

        }

        // Emit the imports.

        StringBuilder sb = new StringBuilder();

        for (final String importName : importNameSet) {

            emitLine(sb, 0, "import " + importName + ";");

        }

        return sb.toString();

    }

    /**

     * Get the Java source code for the given top-level class.

     * @param classRep the representation for the top-level class.

     * @return the java source

     * @throws JavaGenerationException

     */

    public static String generateSourceCode(JavaClassRep classRep) throws JavaGenerationException {

        StringBuilder sb = new StringBuilder();

        JavaTypeName classTypeName = classRep.getClassName();

        String packageName = classTypeName.getPackageName();

        // Create a generation context..

        GenerationContext context = new GenerationContext(classTypeName);

        // Emit the class comemnt if any.

        if (classRep.getComment() != null) {

            sb.append(getSource(classRep.getComment(), context, 0));

            emitLine(sb);

        }

        // Emit SC package and banner

        emitLine(sb, 0, "package " + packageName + ";");

        emitLine(sb);

        // Next we need to walk the java model building up the import information.

        ImportGenerator ig = new ImportGenerator(context);

        classRep.accept(ig, null);

        // Emit imports and class comment.

        String imports = genS_Imports(packageName, classTypeName.getFullJavaSourceName(), context);

        sb.append(imports);

        emitLine(sb);

        sb.append(getSource(classRep, context, 0));

        return sb.toString();

    }

    /**

     * Get a String consisting of the opening line for a Java declaration for the given Java class rep.

     * eg. "public static class Foo extends Bar implements Baz {"

     *

     * @param classRep the Java class representation

     * @param context the generation context

     * @return the opening line of the Java class, ending in an open paren.

     */

    private static String getClassDeclaration(JavaClassRep classRep, GenerationContext context) {

        String unqualifiedClassName = ((JavaTypeName.Reference.Object)classRep.getClassName()).getBaseName();

        StringBuilder classDeclaration = new StringBuilder(Modifier.toString(classRep.getModifiers()));

        classDeclaration.append(" class " + unqualifiedClassName + " ");

        JavaTypeName superclassName = classRep.getSuperclassName();

        if (!superclassName.equals(JavaTypeName.OBJECT)) {

            classDeclaration.append("extends " + context.getSourceName(superclassName) + " ");

        }

        final int nInterfaces = classRep.getNInterfaces();

        if (nInterfaces > 0) {

            classDeclaration.append("implements ");

            for (int i = 0; i < nInterfaces; i++) {

                if (i > 0) {

                    classDeclaration.append(", ");

                }

                classDeclaration.append(context.getSourceName(classRep.getInterface(i)));

            }

            classDeclaration.append(" ");

        }

        classDeclaration.append("{");

        return classDeclaration.toString();

    }

    /**

     * Get a String consisting of the opening line for a Java declaration for the given Java constructor.

     * eg. "public static Bar() {"

     *

     * @param javaConstructor

     * @param context the generation context

     * @return the opening line of the Java constructor, ending in an open paren.

     */

    private static String getConstructorDeclaration(JavaConstructor javaConstructor, GenerationContext context) {

        // Initialize with access flags.

        StringBuilder constructorDeclaration = new StringBuilder(Modifier.toString(javaConstructor.getModifiers())).append(' ');

        // Method name

        constructorDeclaration.append(javaConstructor.getConstructorName() + "(");

        // Parameters

        final int nParams = javaConstructor.getNParams();

        for (int i = 0; i < nParams; i++) {

            if (i > 0) {

                constructorDeclaration.append(", ");

            }

            constructorDeclaration.append(context.getSourceName(javaConstructor.getParamType(i)) + " " + javaConstructor.getParamName(i));

        }

        // Close paren, open brace

        constructorDeclaration.append(") {");

        return constructorDeclaration.toString();

    }

    /**

     * Get a String consisting of the opening line for a Java declaration for the given Java method.

     * eg. "public static void foo throws Bar {"

     *

     * @param javaMethod the Java method representation

     * @param context the generation context

     * @return the opening line of the Java method, ending in an open paren.

     */

    private static String getMethodDeclaration(JavaMethod javaMethod, GenerationContext context) {

        // Initialize with access flags.

        StringBuilder methodDeclaration = new StringBuilder(Modifier.toString(javaMethod.getModifiers())).append(' ');

        // Return type

        methodDeclaration.append(context.getSourceName(javaMethod.getReturnType()) + " ");

        // Method name

        methodDeclaration.append(javaMethod.getMethodName() + "(");

        // Parameters

        for (int i = 0, nParams = javaMethod.getNParams(); i < nParams; i++) {

            if (i > 0) {

                methodDeclaration.append(", ");

            }

            if (javaMethod.isParamFinal(i)) {

                methodDeclaration.append("final ");

            }

            methodDeclaration.append(context.getSourceName(javaMethod.getParamType(i))).append(" ").append(javaMethod.getParamName(i));

        }

        // Close paren

        methodDeclaration.append(") ");

        // throws

        final int nThrownExceptions = javaMethod.getNThrownExceptions();

        if (nThrownExceptions > 0) {

            methodDeclaration.append("throws ");

            for (int i = 0; i < nThrownExceptions; ++i) {

                JavaTypeName thrownExceptionName = javaMethod.getThrownException(i);

                methodDeclaration.append(context.getSourceName(thrownExceptionName));

                if (i < nThrownExceptions - 1) {

                    methodDeclaration.append(",");

                }

                methodDeclaration.append(" ");

            }

        }

        // Open brace

        methodDeclaration.append("{");

        return methodDeclaration.toString();

    }

    /**

     * Get the Java source for a given java class representation.

     * @param classRep the java class representation

     * @param context the generation context

     * @param indent the indent level of the source

     * @return the java source

     * @throws JavaGenerationException

     */

    private static String getSource(JavaClassRep classRep, GenerationContext context, int indent) throws JavaGenerationException{

        StringBuilder sb = new StringBuilder();

        // Emit class JavaDoc

        if (classRep.getJavaDoc() != null) {

            sb.append(getSource(classRep.getJavaDoc(), context, indent).toString());

        }

        // Emit class declaration

        {

            emitLine(sb, indent, getClassDeclaration(classRep, context));

        }

        Iterator<Object> elements = classRep.getClassContent().iterator();

        while (elements.hasNext()) {

            Object element = elements.next();

            if (element instanceof JavaFieldDeclaration) {

                // Emit a field declaration.

                JavaFieldDeclaration fieldDeclaration = (JavaFieldDeclaration)element;

                sb.append(getSource(fieldDeclaration, context, indent+1));

            } else

            if (element instanceof JavaConstructor) {

                // Emit constructor

                JavaConstructor javaConstructor = (JavaConstructor)element;

                sb.append(getSource(javaConstructor, context, indent + 1));

                // extra EOL

                emitLine(sb);

            } else

            if (element instanceof JavaMethod) {

                // Emit method

                JavaMethod javaMethod = (JavaMethod)element;

                sb.append(getSource(javaMethod, context, indent + 1));

                // extra EOL

                emitLine(sb);

            } else

            if (element instanceof JavaClassRep) {

                // Emit inner classe

                JavaClassRep innerClassRep = (JavaClassRep)element;

                sb.append(getSource(innerClassRep, context, indent + 1));

                // extra EOL

            } else

            if (element instanceof MultiLineComment) {

                sb.append(getSource((MultiLineComment)element, context, indent + 1));

                emitLine(sb);

            } else {

                throw new JavaGenerationException ("Unhandled top level element in JavaClassRep: " + element.getClass().getName());

            }

        }

        // Close paren.

        {

            emitLine(sb, indent, "}");

        }

        return sb.toString();

    }

    /**

     * Get the Java source for a given java field declaration.

     * @param fieldDeclaration the java field declaration

     * @param context the generation context

     * @param indent the indent level of the source

     * @return String

     * @throws JavaGenerationException

     */

    private static String getSource(JavaFieldDeclaration fieldDeclaration, GenerationContext context, int indent) throws JavaGenerationException {

        StringBuilder block = new StringBuilder();

        JavaDocComment jdc = fieldDeclaration.getJavaDoc();

        if (jdc != null) {

            block.append(getSource(jdc, context, indent));

        }

        String fieldName = fieldDeclaration.getFieldName();

        JavaTypeName fieldType = fieldDeclaration.getFieldType();

        JavaExpression initializer = fieldDeclaration.getInitializer();

        // flags, type, name

        final StringBuilder declaration;

        {

            final String modifiers = Modifier.toString(fieldDeclaration.getModifiers());

            if (modifiers.length() > 0) {

                declaration = new StringBuilder(modifiers).append(' ');

            } else {

                declaration = new StringBuilder();

            }

        }

        declaration.append(context.getSourceName(fieldType)).append(' ').append(fieldName);

        // " = " , initializer.

        if (initializer != null) {

            declaration.append(" = ");

            declaration.append(getSource(initializer, indent, declaration.length(), context));

        }

        declaration.append(";");

        emitLine(block, indent, declaration.toString());

        emitLine(block);

        return block.toString();

    }

    /**

     * Get the Java source for a given java constructor.

     * @param javaConstructor the Java constructor representation

     * @param context the generation context

     * @param indent the indent level of the source

     * @return String

     * @throws JavaGenerationException

     */

    private static String getSource(JavaConstructor javaConstructor, GenerationContext context, int indent) throws JavaGenerationException {

        StringBuilder sb = new StringBuilder();

        emitLine(sb, indent, getConstructorDeclaration(javaConstructor, context));

        if (javaConstructor.getSuperConstructorParamValues().length > 0) {

            StringBuilder superCall = new StringBuilder();

            superCall.append("super (");

            for (int i = 0, n = javaConstructor.getSuperConstructorParamValues().length; i < n; ++i) {

                superCall.append(getSource(javaConstructor.getSuperConstructorParamValues()[i], indent + 1, superCall.length(), context));

                if (i < (n-1)) {

                    superCall.append(", ");

                }

            }

            superCall.append(");");

            emitLine(sb, indent+1, superCall.toString());

        }

        sb.append(getSource(javaConstructor.getBodyCode(), context, indent + 1));

        emitLine(sb, indent, "}");

        return sb.toString();

    }

    /**

     * Get the Java source for a given java method.

     * @param javaMethod the Java method representation

     * @param context the generation context

     * @param indent the indent level of the source

     * @return String

     * @throws JavaGenerationException

     */

    private static String getSource(JavaMethod javaMethod, GenerationContext context, int indent) throws JavaGenerationException {

        StringBuilder sb = new StringBuilder();

        if (javaMethod.getJavaDocComment() != null) {

            sb.append(getSource(javaMethod.getJavaDocComment(), context, indent));

        }

        emitLine(sb, indent, getMethodDeclaration(javaMethod, context));

        sb.append(getSource(javaMethod.getBodyCode(), context, indent + 1));

        emitLine(sb, indent, "}");

        return sb.toString();

    }

    /**

     * Get the Java source for a given java statement.

     * @param statement the java statement for which to generate source.

     * @param context the generation context.

     * @param indent the indent level of the source

     * @return StringBuilder

     * @throws JavaGenerationException

     */

    private static StringBuilder getSource(JavaStatement statement, GenerationContext context, int indent) throws JavaGenerationException {

        StringBuilder sb = new StringBuilder();

        if (statement instanceof LocalVariableDeclaration) {

            LocalVariableDeclaration declaration = (LocalVariableDeclaration)statement;

            LocalVariable localVariable = declaration.getLocalVariable();

            emitIndent(sb, indent);

            // final

            if (declaration.isFinal()) {

                sb.append("final ");

            }

            // variable type and name

            sb.append(context.getSourceName(localVariable.getTypeName()) + " " + localVariable.getName());

            // " = " + initializer

            JavaExpression initializer = declaration.getInitializer();

            if (initializer != null) {

                sb.append(" = ");

                sb.append(getSource(initializer, indent, sb.length(), context));

            }

            // ;

            sb.append(";" + EOL);

        } else if (statement instanceof ExpressionStatement) {

            ExpressionStatement expressionStatement = (ExpressionStatement)statement;

            String expressionSource = getSource(expressionStatement.getJavaExpression(), indent, 0, context);

            emitLine(sb, 0, expressionSource + ";");

        } else if (statement instanceof LineComment) {

            LineComment lineComment = (LineComment)statement;

            emitLine(sb, indent, "// " + lineComment.getCommentText());

        } else if (statement instanceof MultiLineComment) {

            boolean isJavaDoc = (statement instanceof JavaDocComment);

            MultiLineComment jdc = (MultiLineComment)statement;

            Iterator<String> it = jdc.getCommentLines().iterator();

            String firstLine = it.next();

            boolean nd = !firstLine.startsWith("/*");

            if (nd) {

                emitLine(sb, indent, isJavaDoc ? "/**" : "/*");

            }

            it = jdc.getCommentLines().iterator();

            while (it.hasNext()) {

                String line = it.next();

                if (nd) {

                    emitLine(sb, indent, " * " + line);

                } else {

                    emitLine(sb, indent, line);

                }

            }

            if (nd) {

                emitLine(sb, indent, " */");

            }

        } else if (statement instanceof ReturnStatement) {

            ReturnStatement returnStatement = (ReturnStatement)statement;

            if (returnStatement.getReturnExpression() == null) {

                emitLine(sb, indent, "return;");

            } else {

                emitLine(sb, indent, "return " + getSource(returnStatement.getReturnExpression(),indent, 7, context) +  ";");

            }

        } else if (statement instanceof IfThenElseStatement) {

            IfThenElseStatement iteStatement = (IfThenElseStatement)statement;

            emitLine(sb, indent, "if (" + getSource(iteStatement.getCondition(), indent, 4, context) + ") {");

            sb.append(getSource(iteStatement.getThenStatement(), context, indent + 1));

            // Emit the else clause only if there is one.

            StringBuilder elseClause = getSource(iteStatement.getElseStatement(), context, indent + 1);

            if (elseClause.length() > 0) {

                emitLine(sb, indent, "} else {");

                sb.append(elseClause);

            }

            emitLine(sb, indent, "}");

        } else if (statement instanceof SwitchStatement) {

            SwitchStatement switchStatement = (SwitchStatement)statement;

            JavaExpression condition = switchStatement.getCondition();

            List<IntCaseGroup> caseGroups = switchStatement.getCaseGroups();

            JavaStatement defaultStatementGroup = switchStatement.getDefaultStatement();

            // Sort cases by the first case label in each group.

            Collections.sort(caseGroups, new Comparator<IntCaseGroup>() {

                public int compare(IntCaseGroup o1, IntCaseGroup o2) {

                    int int1 = o1.getNthCaseLabel(0);

                    int int2 = o2.getNthCaseLabel(0);

                    if (int1 < int2) {

                        return -1;

                    }

                    if (int1 > int2) {

                        return 1;

                    }

                    return 0;

                }

            });

            emitIndent (sb, indent);

            int length = sb.length();

            sb.append("switch (");

            String conditionString = getSource(condition, 0, 0, context, true);

            conditionString = conditionString.replaceAll(EOL," ");

            sb.append(conditionString);

            if (sb.lastIndexOf(EOL, length) >= 0) {

                emitLine(sb);

                emitIndent(sb, indent);

                for (int i = 0; i < 7; ++i) {

                    sb.append(" ");

                }

                sb.append (") {");

                emitLine (sb);

            } else {

                sb.append(") {");

                emitLine(sb);

            }

            emitLine(sb);

            // case labels and their statement groups.

            for (final IntCaseGroup switchCaseGroup : caseGroups) {

                JavaStatement caseStatementGroup = switchCaseGroup.getStatement();

                int nCaseLabels = switchCaseGroup.getNCaseLabels();

                for (int i = 0; i < nCaseLabels - 1; i++) {

                    emitLine(sb, indent + 1, "case " + switchCaseGroup.getNthCaseLabel(i) + ":");

                }

                emitLine(sb, indent + 1, "case " + switchCaseGroup.getNthCaseLabel(nCaseLabels - 1) + ": {");

                sb.append(getSource(caseStatementGroup, context, indent + 2));

                emitLine(sb, indent + 1, "}");

                emitLine(sb);

            }

            // default label and statement group.

            if (defaultStatementGroup != null) {

                emitLine(sb, indent + 1, "default: {");

                sb.append(getSource(defaultStatementGroup, context, indent + 2));

                emitLine(sb, indent + 1, "}");

            }

            emitLine(sb, indent, "}");

        } else if (statement instanceof Block) {

            Block block = (Block)statement;

            int blockIndent = indent;

            List<JavaExceptionHandler> exceptionHandlers = block.getExceptionHandlers();

            if (!exceptionHandlers.isEmpty()) {

                emitLine(sb, indent, "try {");

                blockIndent++;

            }

            boolean doingLocalVarDeclarations = false;

            boolean wasLineComment = false;

            int nStatements = block.getNBlockStatements();

            for (int i = 0; i < nStatements; i++) {

                JavaStatement blockStatement = block.getNthBlockStatement(i);

                // Try to separate local var declarations from other types of block statements.

                boolean isLocalVarDeclaration = blockStatement instanceof LocalVariableDeclaration;

                if (!wasLineComment && isLocalVarDeclaration != doingLocalVarDeclarations && i > 0) {

                    sb.append(EOL);

                }

                doingLocalVarDeclarations = isLocalVarDeclaration;

                wasLineComment = blockStatement instanceof LineComment;

                // Now append the source.

                sb.append(getSource(blockStatement, context, blockIndent));

            }

            if (!exceptionHandlers.isEmpty()) {

                for (final JavaExceptionHandler eh : exceptionHandlers) {

                    emitLine(sb, indent, "} catch (" + fixupClassName(eh.getExceptionClass().getName()) + " " + eh.getExceptionVarName() + ") {");

                    sb.append(getSource(eh.getHandlerCode(), context, blockIndent));

                }

                emitLine(sb, indent, "}");

            }

        } else

        if (statement instanceof ThrowStatement) {

            ThrowStatement throwStatement = (ThrowStatement)statement;

            emitLine(sb, indent, "throw " + getSource(throwStatement.getThrownExpression(), indent, 6, context) + ";");

        } else

        if (statement instanceof UnconditionalLoop) {

            UnconditionalLoop whileStatement = (UnconditionalLoop)statement;

            emitLine (sb, indent, whileStatement.getLabel() + ": while (true) {");

            sb.append(getSource(whileStatement.getBody(), context, indent + 1));

            emitLine (sb, indent, "}");

        } else

        if (statement instanceof LabelledContinue) {

            LabelledContinue lc = (LabelledContinue)statement;

            emitLine (sb, indent, "continue " + lc.getLabel() + ";");

        } else

        if (statement instanceof SynchronizedMethodInvocation){

            // A method invocation wrapped in a synchronization block.

            SynchronizedMethodInvocation sof = (SynchronizedMethodInvocation)statement;

            // Start the synchronized block.

            emitLine (sb, indent, "synchronized (" + getSource(sof.getSynchronizingObject(), indent, 14, context) + ") {");

            // Add the method invocation.

            sb.append (getSource(new ExpressionStatement(sof.getMethodInvocation()), context, indent + 1));

            // Finish the block.

            emitLine (sb, indent, "}");

        } else

        if (statement instanceof AssertStatement) {

            AssertStatement ast = (AssertStatement)statement;

            JavaExpression conditionExpression = ast.getConditionExpr();

            JavaExpression failureExpression = ast.getOnFailureExpr();

            if (failureExpression != null) {

                emitIndent(sb, indent);

                sb.append("assert (");

                sb.append(getSource(conditionExpression, indent, 8, context));

                sb.append(") : (");

                sb.append(getSource(failureExpression, indent+1, 5, context));

                sb.append(");");

                emitLine(sb);

            } else {