* Copyright (c) 2010 Contributors

* All rights reserved.

* This program and the accompanying materials are made available

* under the terms of the Eclipse Public License v1.0

* which accompanies this distribution and is available at

* http://www.eclipse.org/legal/epl-v10.html

* 

* Contributors:

*     Andy Clement - SpringSource

* ******************************************************************/

  StringBuilder output;

  private int tab = 0;

  MethodScope mscope;

  AbstractMethodDeclaration declaration;

  protected int expressionLevel = 0;

  public CommonPrinter(MethodScope mscope) {

    output = new StringBuilder();

    this.mscope = mscope;

  }

  protected StringBuilder printTypeReference(TypeReference tr) {

    if (tr instanceof Wildcard) {

      Wildcard w = (Wildcard) tr;

      output.append('?');

      if (w.bound != null) {

        if (w.kind == Wildcard.EXTENDS) {

          output.append(" extends ");

        } else if (w.kind == Wildcard.SUPER) {

          output.append(" super ");

        }

        printTypeReference(w.bound);

      }

      return output;

    } else if (tr instanceof ParameterizedSingleTypeReference) {

      ParameterizedSingleTypeReference pstr = (ParameterizedSingleTypeReference) tr;

      ReferenceBinding tb = (ReferenceBinding) mscope.getType(pstr.token);

      output.append(CharOperation.concatWith(tb.compoundName, '.'));

      output.append('<');

      TypeReference[] typeArguments = pstr.typeArguments;

      for (int i = 0; i < typeArguments.length; i++) {

        if (i > 0) {

          output.append(',');

        }

        printTypeReference(typeArguments[i]);

      }

      output.append('>');

      for (int i = 0; i < pstr.dimensions; i++) {

        output.append("[]"); //$NON-NLS-1$

      }

      return output;

    } else if (tr instanceof ParameterizedQualifiedTypeReference) {

      ParameterizedQualifiedTypeReference pqtr = (ParameterizedQualifiedTypeReference) tr;

      output.append(CharOperation.concatWith(pqtr.tokens, '.'));

      output.append('<');

      TypeReference[][] typeArguments = pqtr.typeArguments;

      // TODO don't support parameterized interim name components

      TypeReference[] ofInterest = typeArguments[typeArguments.length - 1];

      for (int i = 0; i < ofInterest.length; i++) {

        if (i > 0) {

          output.append(',');

        }

        printTypeReference(ofInterest[i]);

      }

      output.append('>');

      for (int i = 0; i < pqtr.dimensions(); i++) {

        output.append("[]"); //$NON-NLS-1$

      }

      return output;

    } else if (tr instanceof SingleTypeReference) {

      SingleTypeReference str = (SingleTypeReference) tr;

      TypeBinding tb = mscope.getType(str.token);

      output.append(tb.debugName()); // fq name

      for (int i = 0; i < str.dimensions(); i++) {

        output.append("[]"); //$NON-NLS-1$

      }

      return output;

    } else if (tr instanceof QualifiedTypeReference) {

      QualifiedTypeReference qtr = (QualifiedTypeReference) tr;

      output.append(CharOperation.concatWith(qtr.tokens, '.'));

      for (int i = 0; i < qtr.dimensions(); i++) {

        output.append("[]"); //$NON-NLS-1$

      }

      return output;

    }

    throwit(tr);

    return output;

  }

  protected StringBuilder printMemberValuePair(MemberValuePair mvp) {

    output.append(mvp.name).append(" = "); //$NON-NLS-1$

    printExpression(mvp.value);

    return output;

  }

  protected StringBuilder printAnnotations(Annotation[] annotations) {

    int length = annotations.length;

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

      printAnnotation(annotations[i]);

      output.append(" "); //$NON-NLS-1$

    }

    return output;

  }

  public StringBuilder printAnnotation(Annotation annotation) {

    output.append('@');

    printExpression(annotation.type);

    MemberValuePair[] mvps = annotation.memberValuePairs();

    if (mvps != null && mvps.length > 0) {

      output.append('(');

      for (int m = 0; m < mvps.length; m++) {

        if (m > 0) {

          output.append(',');

        }

        printMemberValuePair(mvps[m]);

      }

      output.append(')');

    }

    return output;

  }

  public String toString() {

    return output.toString();

  }

  protected StringBuilder printBody(int indent) {

    if (declaration.isAbstract()) { // || (md.modifiers & ExtraCompilerModifiers.AccSemicolonBody) != 0) {

      return output.append(';');

    }

    output.append(" {"); //$NON-NLS-1$

    if (declaration.statements != null) {

      for (int i = 0; i < declaration.statements.length; i++) {

        output.append('\n');

        printStatement(declaration.statements[i], indent);

      }

    }

    output.append('\n');

    printIndent(indent == 0 ? 0 : indent - 1).append('}');

    return output;

  }

  protected StringBuilder printBody(AbstractMethodDeclaration amd, int indent) {

    if (amd.isAbstract()) { // || (md.modifiers & ExtraCompilerModifiers.AccSemicolonBody) != 0) {

      return output.append(';');

    }

    output.append(" {"); //$NON-NLS-1$

    if (amd.statements != null) {

      for (int i = 0; i < amd.statements.length; i++) {

        output.append('\n');

        printStatement(amd.statements[i], indent);

      }

    }

    output.append('\n');

    printIndent(indent == 0 ? 0 : indent - 1).append('}');

    return output;

  }

  protected StringBuilder printArgument(Argument argument) {

    // printIndent(indent, output);

    printModifiers(argument.modifiers);

    if (argument.annotations != null) {

      printAnnotations(argument.annotations);

    }

    printTypeReference(argument.type).append(' ');

    return output.append(argument.name);

  }

  void throwit(Object o) {

    if (true) {

      System.out.println("so far:" + output.toString());

      throw new IllegalStateException(o == null ? "" : o.getClass().getName() + ":" + o);

    }

  }

  void throwit() {

    if (true) {

      throw new IllegalStateException();

    }

  }

  public StringBuilder printIndent(int indent) {

    for (int i = indent; i > 0; i--) {

      output.append("  "); //$NON-NLS-1$

    }

    return output;

  }

  public StringBuilder printModifiers(int modifiers) {

    if ((modifiers & ClassFileConstants.AccPublic) != 0) {

      output.append("public "); //$NON-NLS-1$

    }

    if ((modifiers & ClassFileConstants.AccPrivate) != 0) {

      output.append("private "); //$NON-NLS-1$

    }

    if ((modifiers & ClassFileConstants.AccProtected) != 0) {

      output.append("protected "); //$NON-NLS-1$

    }

    if ((modifiers & ClassFileConstants.AccStatic) != 0) {

      output.append("static "); //$NON-NLS-1$

    }

    if ((modifiers & ClassFileConstants.AccFinal) != 0) {

      output.append("final "); //$NON-NLS-1$

    }

    if ((modifiers & ClassFileConstants.AccSynchronized) != 0) {

      output.append("synchronized "); //$NON-NLS-1$

    }

    if ((modifiers & ClassFileConstants.AccVolatile) != 0) {

      output.append("volatile "); //$NON-NLS-1$

    }

    if ((modifiers & ClassFileConstants.AccTransient) != 0) {

      output.append("transient "); //$NON-NLS-1$

    }

    if ((modifiers & ClassFileConstants.AccNative) != 0) {

      output.append("native "); //$NON-NLS-1$

    }

    if ((modifiers & ClassFileConstants.AccAbstract) != 0) {

      output.append("abstract "); //$NON-NLS-1$

    }

    return output;

  }

  public StringBuilder printExpression(Expression e) {

    // TODO other literals

    try {

      expressionLevel++;

      if (e instanceof TypeReference) {

        return printTypeReference((TypeReference) e);

      } else if (e instanceof IntLiteral) {

        return output.append(((IntLiteral) e).value);

      } else if (e instanceof CharLiteral) {

        return output.append(((CharLiteral) e).source());

      } else if (e instanceof DoubleLiteral) {

        return output.append(((DoubleLiteral) e).source());

      } else if (e instanceof LongLiteral) {

        return output.append(((LongLiteral) e).source());

      } else if (e instanceof FloatLiteral) {

        return output.append(((FloatLiteral) e).source());

      } else if (e instanceof TrueLiteral) {

        return output.append(((TrueLiteral) e).source());

      } else if (e instanceof FalseLiteral) {

        return output.append(((FalseLiteral) e).source());

      } else if (e instanceof ClassLiteralAccess) {

        printTypeReference(((ClassLiteralAccess) e).type);

        return output.append(".class");

      } else if (e instanceof StringLiteral) {

        return printStringLiteral((StringLiteral) e);

      } else if (e instanceof SingleNameReference) {

        SingleNameReference snr = (SingleNameReference) e;

        if (snr.binding instanceof ReferenceBinding) {

          output.append(CharOperation.concatWith(((ReferenceBinding) snr.binding).compoundName, '.'));

        } else if (snr.binding instanceof ParameterizedFieldBinding) {

          ParameterizedFieldBinding pfb = (ParameterizedFieldBinding) snr.binding;

          output.append(pfb.name);

        } else if (snr.binding instanceof LocalVariableBinding) {

          LocalVariableBinding lvb = (LocalVariableBinding) snr.binding;

          output.append(lvb.name);

        } else if (snr.binding instanceof FieldBinding) {

          FieldBinding fb = (FieldBinding) snr.binding;

          ReferenceBinding rb = fb.declaringClass;

          if (fb.isStatic()) {

            // qualify it

            output.append(CharOperation.concatWith(rb.compoundName, '.'));

            output.append('.');

            output.append(fb.name);

          } else {

            output.append(snr.token);

          }

          int stop = 1;

        } else {

          throwit(snr.binding);

        }

        return output;

      } else if (e instanceof QualifiedNameReference) {

        QualifiedNameReference qnr = (QualifiedNameReference) e;

        if (qnr.binding instanceof FieldBinding) {

          FieldBinding fb = (FieldBinding) qnr.binding;

          ReferenceBinding rb = fb.declaringClass;

          if (fb.isStatic()) {

            output.append(CharOperation.concatWith(rb.compoundName, '.'));

            output.append('.');

            output.append(fb.name);

          } else {

            output.append(CharOperation.concatWith(qnr.tokens, '.'));// ((ReferenceBinding) qnr.binding).compoundName,

          }

        } else if (qnr.binding instanceof ReferenceBinding) {

          output.append(CharOperation.concatWith(qnr.tokens, '.'));// ((ReferenceBinding) qnr.binding).compoundName,

          // '.'));

        } else if (qnr.binding instanceof LocalVariableBinding) {

          output.append(CharOperation.concatWith(qnr.tokens, '.'));// oncatWith(((LocalVariableBinding)

          // qnr.binding).compoundName, '.'));

          // LocalVariableBinding lvb = (LocalVariableBinding) qnr.binding;

          // output.append(lvb.name);

        } else {

          throwit(qnr.binding);

        }

        // output.append(qnr.actualReceiverType.debugName());

        // output.append('.');

        // output.append(qnr.tokens[qnr.tokens.length - 1]);

        return output;

      } else if (e instanceof ArrayReference) {

        ArrayReference ar = (ArrayReference) e;

        printExpression(ar.receiver).append('[');

        return printExpression(ar.position).append(']');

      } else if (e instanceof MessageSend) {

        return printMessageSendStatement((MessageSend) e);

      } else if (e instanceof ThisReference) {

        ThisReference tr = (ThisReference) e;

        if (tr.isImplicitThis()) {

          return output;

        }

        return output.append("this"); //$NON-NLS-1$

      } else if (e instanceof CastExpression) {

        return printCastExpression((CastExpression) e);

      } else if (e instanceof BinaryExpression) {

        if (expressionLevel != 0) {

          output.append('(');

        }

        expressionLevel++;

        BinaryExpression be = (BinaryExpression) e;

        printExpression(be.left).append(' ').append(be.operatorToString()).append(' ');

        printExpression(be.right);

        expressionLevel--;

        if (expressionLevel != 0) {

          output.append(')');

        }

        return output;

      } else if (e instanceof NullLiteral) {

        return output.append("null");

      } else if (e instanceof QualifiedAllocationExpression) {

        return printQualifiedAllocationExpression((QualifiedAllocationExpression) e, 0);

      } else if (e instanceof AllocationExpression) {

        return printAllocationExpression((AllocationExpression) e);

      } else if (e instanceof ArrayInitializer) {

        return printArrayInitialized((ArrayInitializer) e);

      } else if (e instanceof FieldReference) {

        return printFieldReference((FieldReference) e);

      } else if (e instanceof UnaryExpression) {

        return printUnaryExpression((UnaryExpression) e);

      } else if (e instanceof InstanceOfExpression) {

        return printInstanceOfExpression((InstanceOfExpression) e);

      } else if (e instanceof Assignment) {

        return printAssignment((Assignment) e, false);

      } else if (e instanceof ArrayAllocationExpression) {

        return printArrayAllocationExpression((ArrayAllocationExpression) e);

      } else if (e instanceof ConditionalExpression) {

        return printConditionalExpression((ConditionalExpression) e);

      }

      throwit(e);

      return output;

    } finally {

      expressionLevel--;

    }

  }

  private StringBuilder printConditionalExpression(ConditionalExpression e) {

    if (expressionLevel != 0) {

      output.append('(');

    }

    expressionLevel++;

    printExpression(e.condition).append(" ? ");

    printExpression(e.valueIfTrue).append(" : ");

    printExpression(e.valueIfFalse);

    expressionLevel--;

    if (expressionLevel != 0) {

      output.append(')');

    }

    return output;

  }

  private StringBuilder printArrayAllocationExpression(ArrayAllocationExpression aae) {

    output.append("new "); //$NON-NLS-1$

    printTypeReference(aae.type);

    for (int i = 0; i < aae.dimensions.length; i++) {

      if (aae.dimensions[i] == null) {

        output.append("[]"); //$NON-NLS-1$

      } else {

        output.append('[');

        printExpression(aae.dimensions[i]);

        output.append(']');

      }

    }

    if (aae.initializer != null) {

      printExpression(aae.initializer);

    }

    return output;

  }

  private StringBuilder printInstanceOfExpression(InstanceOfExpression e) {

    if (expressionLevel != 0) {

      output.append('(');

    }

    expressionLevel++;

    printExpression(e.expression).append(" instanceof "); //$NON-NLS-1$

    printTypeReference(e.type);

    expressionLevel--;

    if (expressionLevel != 0) {

      output.append(')');

    }

    return output;

  }

  private StringBuilder printUnaryExpression(UnaryExpression e) {

    if (expressionLevel != 0) {

      output.append('(');

    }

    expressionLevel++;

    output.append(e.operatorToString()).append(' ');

    printExpression(e.expression);

    expressionLevel--;

    if (expressionLevel != 0) {

      output.append(')');

    }

    return output;

  }

  private StringBuilder printFieldReference(FieldReference fr) {

    printExpression(fr.receiver).append('.').append(fr.token);

    return output;

  }

  private StringBuilder printArrayInitialized(ArrayInitializer e) {

    output.append('{');

    if (e.expressions != null) {

      // int j = 20;

      for (int i = 0; i < e.expressions.length; i++) {

        if (i > 0) {

          output.append(", "); //$NON-NLS-1$

        }

        printExpression(e.expressions[i]);

        // expressions[i].printExpression(0, output);

        // j--;

        // if (j == 0) {

        // output.append('\n');

        // printIndent(indent + 1, output);

        // j = 20;

        // }

      }

    }

    return output.append('}');

  }

  private StringBuilder printCastExpression(CastExpression e) {

    output.append('(');

    output.append('(');

    printExpression(e.type).append(") "); //$NON-NLS-1$

    printExpression(e.expression);

    output.append(')');

    return output;

  }

  private StringBuilder printStringLiteral(StringLiteral e) {

    output.append('\"');

    for (int i = 0; i < e.source().length; i++) {

      switch (e.source()[i]) {

      case '\b':

        output.append("\\b"); //$NON-NLS-1$

        break;

      case '\t':

        output.append("\\t"); //$NON-NLS-1$

        break;

      case '\n':

        output.append("\\n"); //$NON-NLS-1$

        break;

      case '\f':

        output.append("\\f"); //$NON-NLS-1$

        break;

      case '\r':

        output.append("\\r"); //$NON-NLS-1$

        break;

      case '\"':

        output.append("\\\""); //$NON-NLS-1$

        break;

      case '\'':

        output.append("\\'"); //$NON-NLS-1$

        break;

      case '\\': // take care not to display the escape as a potential real char

        output.append("\\\\"); //$NON-NLS-1$

        break;

      default:

        output.append(e.source()[i]);

      }

    }

    output.append('\"');

    return output;

  }

  public StringBuilder printExpression(SingleTypeReference str) {

    output.append(str.token);

    return output;

  }

  protected StringBuilder printStatement(Statement statement, int indent) {

    return printStatement(statement, indent, true);

  }

  protected StringBuilder printStatement(Statement statement, int indent, boolean applyIndent) {

    if (statement instanceof ReturnStatement) {

      printIndent(indent).append("return "); //$NON-NLS-1$

      if (((ReturnStatement) statement).expression != null) {

        printExpression(((ReturnStatement) statement).expression);

      }

      return output.append(';');

    } else if (statement instanceof PostfixExpression) {

      return printPostfixExpression((PostfixExpression) statement);

    } else if (statement instanceof PrefixExpression) {

      return printPrefixExpression((PrefixExpression) statement);

    } else if (statement instanceof MessageSend) {

      printIndent(indent);

      MessageSend ms = (MessageSend) statement;

      printMessageSendStatement(ms);

      return output.append(';');

    } else if (statement instanceof QualifiedAllocationExpression) {

      printIndent(indent);

      printQualifiedAllocationExpression((QualifiedAllocationExpression) statement, indent);

      return output.append(';');

    } else if (statement instanceof Assignment) {

      printIndent(indent);

      printAssignment((Assignment) statement);

      return output.append(';');

    } else if (statement instanceof TryStatement) {

      printTryStatement((TryStatement) statement, indent);

      return output;

    } else if (statement instanceof IfStatement) {

      printIndent(indent);

      IfStatement is = (IfStatement) statement;

      printIndent(indent).append("if ("); //$NON-NLS-1$

      printExpression(is.condition).append(")\n"); //$NON-NLS-1$

      printStatement(is.thenStatement, indent + 2);

      if (is.elseStatement != null) {

        output.append('\n');

        printIndent(indent);

        output.append("else\n"); //$NON-NLS-1$

        printStatement(is.elseStatement, indent + 2);

      }

      return output;

    } else if (statement instanceof Block) {

      printBlock((Block) statement, indent, applyIndent);

      return output;

    } else if (statement instanceof LocalDeclaration) {

      return printLocalDeclaration((LocalDeclaration) statement, indent);

    } else if (statement instanceof SwitchStatement) {

      return printSwitchStatement((SwitchStatement) statement, indent);

    } else if (statement instanceof CaseStatement) {

      return printCaseStatement((CaseStatement) statement, indent);

    } else if (statement instanceof BreakStatement) {

      return printBreakStatement((BreakStatement) statement, indent);

    } else if (statement instanceof ThrowStatement) {

      return printThrowStatement((ThrowStatement) statement, indent);

    } else if (statement instanceof TypeDeclaration) {

      return printTypeDeclaration((TypeDeclaration) statement, indent, false).append(';');

    } else if (statement instanceof AssertStatement) {

      return printAssertStatement((AssertStatement) statement, indent);

    } else if (statement instanceof ForStatement) {

      return printForStatement((ForStatement) statement, indent);

    } else if (statement instanceof ForeachStatement) {

      return printForeachStatement((ForeachStatement) statement, indent);

    }

    System.err.println(statement);

    System.err.println(statement.getClass().getName());

    throwit(statement);

    return output;

  }

  private StringBuilder printPostfixExpression(PostfixExpression pe) {

    printExpression(pe.lhs);

    output.append(' ');

    output.append(pe.operatorToString());

    return output;

  }

  private StringBuilder printPrefixExpression(PrefixExpression pe) {

    output.append(pe.operatorToString());

    output.append(' ');

    printExpression(pe.lhs);

    return output;

  }

  public StringBuilder printAsExpression(LocalDeclaration ld, int indent) {

    // printIndent(indent);

    printModifiers(ld.modifiers);

    if (ld.annotations != null) {

      printAnnotations(ld.annotations);

    }

    if (ld.type != null) {

      printTypeReference(ld.type).append(' ');

    }

    output.append(ld.name);

    switch (ld.getKind()) {

    case AbstractVariableDeclaration.ENUM_CONSTANT:

      if (ld.initialization != null) {

        printExpression(ld.initialization);

      }

      break;

    default:

      if (ld.initialization != null) {

        output.append(" = "); //$NON-NLS-1$

        printExpression(ld.initialization);

      }

    }

    return output;

  }

  private StringBuilder printForeachStatement(ForeachStatement statement, int indent) {

    printIndent(indent).append("for ("); //$NON-NLS-1$

    printAsExpression(statement.elementVariable, indent);

    output.append(" : ");//$NON-NLS-1$

    printExpression(statement.collection).append(") "); //$NON-NLS-1$

    // block

    if (statement.action == null) {

      output.append(';');

    } else {

      printStatement(statement.action, indent + 1);

    }

    return output;

  }

  private StringBuilder printForStatement(ForStatement fs, int indent) {

    printIndent(indent).append("for ("); //$NON-NLS-1$

    // inits

    if (fs.initializations != null) {

      for (int i = 0; i < fs.initializations.length; i++) {

        // nice only with expressions

        if (i > 0) {

          output.append(", "); //$NON-NLS-1$

        }

        printStatement(fs.initializations[i], 0);

      }

    }

    if (!output.toString().endsWith(";")) {

      output.append("; "); //$NON-NLS-1$

    }

    // cond

    if (fs.condition != null) {

      printExpression(fs.condition);

    }

    output.append("; "); //$NON-NLS-1$

    // updates

    if (fs.increments != null) {

      for (int i = 0; i < fs.increments.length; i++) {

        if (i > 0) {

          output.append(", "); //$NON-NLS-1$

        }

        printStatement(fs.increments[i], 0);

      }

    }

    output.append(") "); //$NON-NLS-1$

    // block

    if (fs.action == null) {

      output.append(';');

    } else {

      // output.append('\n');

      printStatement(fs.action, indent + 1, false);

    }

    return output;

  }

  private StringBuilder printAssertStatement(AssertStatement as, int indent) {

    printIndent(indent);

    output.append("assert "); //$NON-NLS-1$

    printExpression(as.assertExpression);

    if (as.exceptionArgument != null) {

      output.append(": "); //$NON-NLS-1$

      printExpression(as.exceptionArgument);

    }

    return output.append(';');

  }

  private StringBuilder printThrowStatement(ThrowStatement ts, int indent) {

    printIndent(indent).append("throw "); //$NON-NLS-1$

    printExpression(ts.exception);

    return output.append(';');

  }

  private StringBuilder printBreakStatement(BreakStatement statement, int indent) {

    printIndent(indent).append("break "); //$NON-NLS-1$

    if (statement.label != null) {

      output.append(statement.label);

    }

    return output.append(';');

  }

  private StringBuilder printCaseStatement(CaseStatement statement, int indent) {

    printIndent(indent);

    if (statement.constantExpression == null) {

      output.append("default : "); //$NON-NLS-1$

    } else {

      output.append("case "); //$NON-NLS-1$

      printExpression(statement.constantExpression).append(" : "); //$NON-NLS-1$

    }

    return output;// output.append(';');

  }

  private StringBuilder printSwitchStatement(SwitchStatement statement, int indent) {

    printIndent(indent).append("switch ("); //$NON-NLS-1$

    printExpression(statement.expression).append(") {"); //$NON-NLS-1$

    if (statement.statements != null) {

      for (int i = 0; i < statement.statements.length; i++) {

        output.append('\n');

        if (statement.statements[i] instanceof CaseStatement) {

          printStatement(statement.statements[i], indent);

        } else {

          printStatement(statement.statements[i], indent + 2);

        }

      }

    }

    output.append("\n"); //$NON-NLS-1$

    return printIndent(indent).append('}');

  }

  private StringBuilder printLocalDeclaration(LocalDeclaration statement, int indent) {

    printAbstractVariableDeclarationAsExpression(statement, indent);

    switch (statement.getKind()) {

    case AbstractVariableDeclaration.ENUM_CONSTANT:

      return output.append(',');

    default:

      return output.append(';');

    }

  }

  private StringBuilder printAbstractVariableDeclarationAsExpression(AbstractVariableDeclaration avd, int indent) {

    printIndent(indent);

    printModifiers(avd.modifiers);

    if (avd.annotations != null) {

      printAnnotations(avd.annotations);

    }

    if (avd.type != null) {

      printTypeReference(avd.type).append(' ');

    }

    output.append(avd.name);

    switch (avd.getKind()) {

    case AbstractVariableDeclaration.ENUM_CONSTANT:

      if (avd.initialization != null) {

        printExpression(avd.initialization);

      }

      break;

    default:

      if (avd.initialization != null) {

        output.append(" = "); //$NON-NLS-1$

        printExpression(avd.initialization);

      }

    }

    return output;

  }

  private StringBuilder printBlock(Block b, int indent, boolean applyIndent) {

    if (applyIndent) {

      printIndent(indent);

    }

    output.append("{\n"); //$NON-NLS-1$

    printBody(b, indent);

    printIndent(indent);

    return output.append('}');

  }

  public StringBuilder printBody(Block b, int indent) {

    if (b.statements == null) {

      return output;

    }

    for (int i = 0; i < b.statements.length; i++) {

      printStatement(b.statements[i], indent + 1);

      output.append('\n');

    }

    return output;

  }

  private StringBuilder printTryStatement(TryStatement statement, int indent) {

    printIndent(indent).append("try "); //$NON-NLS-1$

    printBlock(statement.tryBlock, indent, false);

    // catches

    if (statement.catchBlocks != null) {

      for (int i = 0; i < statement.catchBlocks.length; i++) {

        // output.append('\n');

        // printIndent(indent).

        output.append(" catch ("); //$NON-NLS-1$

        printArgument(statement.catchArguments[i]).append(") "); //$NON-NLS-1$

        printBlock(statement.catchBlocks[i], indent, false);

        // statement.catchBlocks[i].printStatement(indent + 1, output);

      }

    }

    // finally

    if (statement.finallyBlock != null) {

      // output.append('\n');

      // printIndent(indent).

      output.append(" finally "); //$NON-NLS-1$

      printBlock(statement.finallyBlock, indent, false);// .printStatement(indent + 1, output);

    }

    return output;

  }

  private StringBuilder printAssignment(Assignment statement) {

    return printAssignment(statement, expressionLevel != 0);

  }

  private StringBuilder printAssignment(Assignment statement, boolean parens) {

    if (parens) {

      output.append('(');

    }

    printExpression(statement.lhs).append(" = ");

    printExpression(statement.expression);

    if (parens) {

      output.append(')');

    }

    return output;

  }

  private StringBuilder printMessageSendStatement(MessageSend ms) {

    if (!ms.receiver.isImplicitThis()) {

      printExpression(ms.receiver).append('.');

    }

    if (ms.typeArguments != null) {

      output.append('<');

      int max = ms.typeArguments.length - 1;

      for (int j = 0; j < max; j++) {

        printTypeReference(ms.typeArguments[j]);

        // ms.typeArguments[j].print(0, output);

        output.append(", ");//$NON-NLS-1$

      }

      printTypeReference(ms.typeArguments[max]);

      // ms.typeArguments[max].print(0, output);

      output.append('>');

    }

    output.append(ms.selector).append('(');

    if (ms.arguments != null) {

      for (int i = 0; i < ms.arguments.length; i++) {

        if (i > 0) {

          output.append(", "); //$NON-NLS-1$

        }

        printExpression(ms.arguments[i]);

      }

    }

    return output.append(')');

  }

  protected StringBuilder printQualifiedAllocationExpression(QualifiedAllocationExpression qae, int indent) {

    if (qae.enclosingInstance != null) {

      printExpression(qae.enclosingInstance).append('.');

    }

    printAllocationExpression(qae);

    if (qae.anonymousType != null) {

      printTypeDeclaration(qae.anonymousType, indent, true);

    }

    return output;

  }

  protected StringBuilder printTypeDeclaration(TypeDeclaration td, int indent, boolean isAnonymous) {

    if (td.javadoc != null) {

      throwit(td);

      // td.javadoc.print(indent, output);

    }

    if ((td.bits & ASTNode.IsAnonymousType) == 0) {

      printIndent(tab);

      printTypeDeclarationHeader(td);

    }

    printTypeDeclarationBody(td, indent, isAnonymous);

    return output;

  }

  public StringBuilder printTypeDeclarationBody(TypeDeclaration td, int indent, boolean isAnonymous) {

    output.append(" {"); //$NON-NLS-1$

    if (td.memberTypes != null) {

      for (int i = 0; i < td.memberTypes.length; i++) {

        if (td.memberTypes[i] != null) {

          output.append('\n');

          printTypeDeclaration(td.memberTypes[i], indent + 1, false);

        }

      }

    }

    if (td.fields != null) {

      for (int fieldI = 0; fieldI < td.fields.length; fieldI++) {

        if (td.fields[fieldI] != null) {

          output.append('\n');

          printFieldDeclaration(td.fields[fieldI], indent + 1);

        }

      }

    }

    if (td.methods != null) {

      for (int i = 0; i < td.methods.length; i++) {

        if (td.methods[i] != null) {

          AbstractMethodDeclaration amd = td.methods[i];

          if (amd instanceof MethodDeclaration) {

            output.append('\n');

            printMethodDeclaration(((MethodDeclaration) amd), indent + 1);

          } else if (amd instanceof ConstructorDeclaration) {

            if (!isAnonymous) {

              output.append('\n');

              // likely to be just a ctor with name 'x' as set in TypeDeclaration.createDefaultConstructorWithBinding

              printConstructorDeclaration(((ConstructorDeclaration) amd), indent + 1);

            }

          } else {

            throwit(amd);

          }

        }

      }

    }

    output.append('\n');

    return printIndent(indent).append('}');

  }

  protected StringBuilder printFieldDeclaration(FieldDeclaration fd, int indent) {

    printIndent(indent);

    printModifiers(fd.modifiers);

    if (fd.annotations != null) {

      printAnnotations(fd.annotations);

    }

    if (fd.type != null) {

      printTypeReference(fd.type).append(' ');

    }

    output.append(fd.name);

    switch (fd.getKind()) {

    case AbstractVariableDeclaration.ENUM_CONSTANT:

      if (fd.initialization != null) {

        printExpression(fd.initialization);

      }

      break;

    default:

      if (fd.initialization != null) {

        output.append(" = "); //$NON-NLS-1$

        printExpression(fd.initialization);

      }

    }

    output.append(';');

    return output;

  }

  protected StringBuilder printConstructorDeclaration(ConstructorDeclaration amd, int tab) {

    if (amd.javadoc != null) {

      throwit();

      // amd.javadoc.print(tab, output);

    }

    printIndent(tab);

    if (amd.annotations != null) {

      printAnnotations(amd.annotations);

    }

    printModifiers(amd.modifiers);

    TypeParameter[] typeParams = amd.typeParameters();

    if (typeParams != null) {

      output.append('<');

      int max = typeParams.length - 1;

      for (int j = 0; j < max; j++) {

        printTypeParameter(typeParams[j]);

        // typeParams[j].print(0, output);

        output.append(", ");//$NON-NLS-1$

      }

      printTypeParameter(typeParams[max]);

      output.append('>');

    }

    // TODO confirm selector is right name

    output.append(amd.selector).append('(');

    if (amd.arguments != null) {

      for (int i = 0; i < amd.arguments.length; i++) {

        if (i > 0) {

          output.append(", "); //$NON-NLS-1$

        }

        printArgument(amd.arguments[i]);

      }

    }

    output.append(')');

    if (amd.thrownExceptions != null) {

      output.append(" throws "); //$NON-NLS-1$

      for (int i = 0; i < amd.thrownExceptions.length; i++) {

        if (i > 0) {

          output.append(", "); //$NON-NLS-1$

        }

        throwit();

        // this.thrownExceptions[i].print(0, output);

      }

    }

    printBody(amd, tab + 1);

    return output;

  }

  private StringBuilder printMethodDeclaration(MethodDeclaration amd, int tab) {

    if (amd.javadoc != null) {

      throwit();

      // amd.javadoc.print(tab, output);

    }

    printIndent(tab);

    if (amd.annotations != null) {

      printAnnotations(amd.annotations);

    }

    printModifiers(amd.modifiers);

    TypeParameter[] typeParams = amd.typeParameters();

    if (typeParams != null) {

      output.append('<');

      int max = typeParams.length - 1;

      for (int j = 0; j < max; j++) {

        printTypeParameter(typeParams[j]);

        // typeParams[j].print(0, output);

        output.append(", ");//$NON-NLS-1$

      }

      printTypeParameter(typeParams[max]);

      output.append('>');

    }

    printReturnType(amd.returnType).append(amd.selector).append('(');

    if (amd.arguments != null) {

      for (int i = 0; i < amd.arguments.length; i++) {

        if (i > 0) {

          output.append(", "); //$NON-NLS-1$

        }

        printArgument(amd.arguments[i]);

      }

    }

    output.append(')');

    if (amd.thrownExceptions != null) {

      output.append(" throws "); //$NON-NLS-1$

      for (int i = 0; i < amd.thrownExceptions.length; i++) {

        if (i > 0) {

          output.append(", "); //$NON-NLS-1$