/*******************************************************************************
 * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v0.5 
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v05.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/
package net.sourceforge.phpdt.internal.formatter;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.util.Hashtable;
import java.util.Locale;
import java.util.Map;

import net.sourceforge.phpdt.core.ICodeFormatter;
import net.sourceforge.phpdt.core.compiler.CharOperation;
import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
import net.sourceforge.phpdt.core.compiler.InvalidInputException;
import net.sourceforge.phpdt.internal.compiler.ConfigurableOption;
import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
import net.sourceforge.phpdt.internal.formatter.impl.FormatterOptions;
import net.sourceforge.phpdt.internal.formatter.impl.SplitLine;

/** <h2>How to format a piece of code ?</h2>
 * <ul><li>Create an instance of <code>CodeFormatter</code>
 * <li>Use the method <code>void format(aString)</code>
 * on this instance to format <code>aString</code>.
 * It will return the formatted string.</ul>
*/
public class CodeFormatter implements ITerminalSymbols, ICodeFormatter {

  public FormatterOptions options;

  /** 
   * Represents a block in the <code>constructions</code> stack.
   */
  public static final int BLOCK = ITerminalSymbols.TokenNameLBRACE;

  /** 
   * Represents a block following a control statement in the <code>constructions</code> stack.
   */
  public static final int NONINDENT_BLOCK = -100;

  /** 
   * Contains the formatted output.
   */
  StringBuffer formattedSource;

  /** 
   * Contains the current line.<br>
   * Will be dumped at the next "newline"
   */
  StringBuffer currentLineBuffer;

  /** 
   * Used during the formatting to get each token.
   */
  Scanner scanner;

  /** 
   * Contains the tokens responsible for the current indentation level
   * and the blocks not closed yet.
   */
  private int[] constructions;

  /** 
   * Index in the <code>constructions</code> array.
   */
  private int constructionsCount;

  /** 
   * Level of indentation of the current token (number of tab char put in front of it).
   */
  private int indentationLevel;

  /** 
   * Regular level of indentation of all the lines
   */
  private int initialIndentationLevel;

  /** 
   * Used to split a line.
   */
  Scanner splitScanner;

  /** 
   * To remember the offset between the beginning of the line and the
   * beginning of the comment.
   */
  int currentCommentOffset;
  int currentLineIndentationLevel;
  int maxLineSize = 30;
  private boolean containsOpenCloseBraces;
  private int indentationLevelForOpenCloseBraces;

  /**
   * Collections of positions to map
   */
  private int[] positionsToMap;

  /**
   * Collections of mapped positions
   */
  private int[] mappedPositions;

  private int indexToMap;

  private int indexInMap;

  private int globalDelta;

  private int lineDelta;

  private int splitDelta;

  private int beginningOfLineIndex;

  private int multipleLineCommentCounter;

  /** 
   * Creates a new instance of Code Formatter using the given settings.
   * 
   * @deprecated backport 1.0 internal functionality
   */
  public CodeFormatter(ConfigurableOption[] settings) {
    this(convertConfigurableOptions(settings));
  }

  /** 
   * Creates a new instance of Code Formatter using the FormattingOptions object
   * given as argument
   * @deprecated Use CodeFormatter(ConfigurableOption[]) instead
   */
  public CodeFormatter() {
    this((Map) null);
  }
  /** 
   * Creates a new instance of Code Formatter using the given settings.
   */
  public CodeFormatter(Map settings) {

    // initialize internal state
    constructionsCount = 0;
    constructions = new int[10];
    currentLineIndentationLevel = indentationLevel = initialIndentationLevel;
    currentCommentOffset = -1;

    // initialize primary and secondary scanners
    scanner = new Scanner(true /*comment*/
    , true /*whitespace*/
    , false /*nls*/
    , false /*assert*/
    ); // regular scanner for forming lines
    scanner.recordLineSeparator = true;

    // to remind of the position of the beginning of the line.
    splitScanner = new Scanner(true /*comment*/
    , true /*whitespace*/
    , false /*nls*/
    , false /*assert*/
    );
    // secondary scanner to split long lines formed by primary scanning

    // initialize current line buffer
    currentLineBuffer = new StringBuffer();
    this.options = new FormatterOptions(settings);
  }

  /**
   * Returns true if a lineSeparator has to be inserted before <code>operator</code>
   * false otherwise.
   */
  private static boolean breakLineBeforeOperator(int operator) {
    switch (operator) {
      case TokenNameCOMMA :
      case TokenNameSEMICOLON :
      case TokenNameEQUAL :
        return false;
      default :
        return true;
    }
  }

  /** 
  * @deprecated backport 1.0 internal functionality
  */
  private static Map convertConfigurableOptions(ConfigurableOption[] settings) {
    Hashtable options = new Hashtable(10);

    for (int i = 0; i < settings.length; i++) {
      if (settings[i].getComponentName().equals(CodeFormatter.class.getName())) {
        String optionName = settings[i].getOptionName();
        int valueIndex = settings[i].getCurrentValueIndex();

        if (optionName.equals("newline.openingBrace")) { //$NON-NLS-1$
          options.put("net.sourceforge.phpdt.core.formatter.newline.openingBrace", valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

        } else if (optionName.equals("newline.controlStatement")) { //$NON-NLS-1$
          options.put("net.sourceforge.phpdt.core.formatter.newline.controlStatement", valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

        } else if (optionName.equals("newline.clearAll")) { //$NON-NLS-1$
          options.put("net.sourceforge.phpdt.core.formatter.newline.clearAll", valueIndex == 0 ? "clear all" : "preserve one"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

        } else if (optionName.equals("newline.elseIf")) { //$NON-NLS-1$
          options.put("net.sourceforge.phpdt.core.formatter.newline.elseIf", valueIndex == 0 ? "do not insert" : "insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

        } else if (optionName.equals("newline.emptyBlock")) { //$NON-NLS-1$
          options.put("net.sourceforge.phpdt.core.formatter.newline.emptyBlock", valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

        } else if (optionName.equals("lineSplit")) { //$NON-NLS-1$
          options.put("net.sourceforge.phpdt.core.formatter.lineSplit", String.valueOf(valueIndex)); //$NON-NLS-1$ //$NON-NLS-2$

        } else if (optionName.equals("style.assignment")) { //$NON-NLS-1$
          options.put("net.sourceforge.phpdt.core.formatter.style.assignment", valueIndex == 0 ? "compact" : "normal"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

        } else if (optionName.equals("tabulation.char")) { //$NON-NLS-1$
          options.put("net.sourceforge.phpdt.core.formatter.tabulation.char", valueIndex == 0 ? "tab" : "space"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

        } else if (optionName.equals("tabulation.size")) { //$NON-NLS-1$
          options.put("net.sourceforge.phpdt.core.formatter.tabulation.size", String.valueOf(valueIndex)); //$NON-NLS-1$ //$NON-NLS-2$
        }
      }
    }

    return options;
  }

  /** 
   * Returns the end of the source code.
   */
  private final String copyRemainingSource() {
    char str[] = scanner.source;
    int startPosition = scanner.startPosition;
    int length = str.length - startPosition;
    StringBuffer bufr = new StringBuffer(length);
    if (startPosition < str.length) {
      bufr.append(str, startPosition, length);
    }
    return (bufr.toString());
  }

  /**
   * Inserts <code>tabCount</code> tab character or their equivalent number of spaces.
   */
  private void dumpTab(int tabCount) {
    if (options.indentWithTab) {
      for (int j = 0; j < tabCount; j++) {
        formattedSource.append('\t');
        increaseSplitDelta(1);
      }
    } else {
      for (int i = 0, max = options.tabSize * tabCount; i < max; i++) {
        formattedSource.append(' ');
        increaseSplitDelta(1);
      }
    }
  }

  /**
   * Dumps <code>currentLineBuffer</code> into the formatted string.
   */
  private void flushBuffer() {
    String currentString = currentLineBuffer.toString();
    splitDelta = 0;
    beginningOfLineIndex = formattedSource.length();
    if (containsOpenCloseBraces) {
      containsOpenCloseBraces = false;
      outputLine(currentString, false, indentationLevelForOpenCloseBraces, 0, -1, null, 0);
      indentationLevelForOpenCloseBraces = currentLineIndentationLevel;
    } else {
      outputLine(currentString, false, currentLineIndentationLevel, 0, -1, null, 0);
    }
    int scannerSourceLength = scanner.source.length;
    if (scannerSourceLength > 2) {
      if (scanner.source[scannerSourceLength - 1] == '\n' && scanner.source[scannerSourceLength - 2] == '\r') {
        formattedSource.append(options.lineSeparatorSequence);
        increaseGlobalDelta(options.lineSeparatorSequence.length - 2);
      } else if (scanner.source[scannerSourceLength - 1] == '\n') {
        formattedSource.append(options.lineSeparatorSequence);
        increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
      } else if (scanner.source[scannerSourceLength - 1] == '\r') {
        formattedSource.append(options.lineSeparatorSequence);
        increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
      }
    }
    updateMappedPositions(scanner.startPosition);
  }

  /** 
   * Formats the input string.
   */
  private void format() {
    int token = 0;
    int previousToken = 0;
    int previousCompilableToken = 0;
    int indentationOffset = 0;
    int newLinesInWhitespace = 0;

    // number of new lines in the previous whitespace token
    // (used to leave blank lines before comments)
    int pendingNewLines = 0;
    boolean expectingOpenBrace = false;
    boolean clearNonBlockIndents = false;
    // true if all indentations till the 1st { (usefull after } or ;)
    boolean pendingSpace = true;
    boolean pendingNewlineAfterParen = false;
    // true when a cr is to be put after a ) (in conditional statements)
    boolean inAssignment = false;
    boolean inArrayAssignment = false;
    boolean inThrowsClause = false;
    boolean inClassOrInterfaceHeader = false;
    int dollarBraceCount = 0;

    // openBracketCount is used to count the number of open brackets not closed yet.
    int openBracketCount = 0;
    int unarySignModifier = 0;

    // openParenthesis[0] is used to count the parenthesis not belonging to a condition
    // (eg foo();). parenthesis in for (...) are count elsewhere in the array.
    int openParenthesisCount = 1;
    int[] openParenthesis = new int[10];

    // tokenBeforeColon is used to know what token goes along with the current :
    // it can be case or ?
    int tokenBeforeColonCount = 0;
    int[] tokenBeforeColon = new int[10];

    constructionsCount = 0; // initializes the constructions count.

    // contains DO if in a DO..WHILE statement, UNITIALIZED otherwise.
    int nlicsToken = 0;

    // fix for 1FF17XY: LFCOM:ALL - Format problem on not matching } and else 
    boolean specialElse = false;

    // OPTION (IndentationLevel): initial indentation level may be non-zero.
    currentLineIndentationLevel += constructionsCount;

    // An InvalidInputException exception might cause the termination of this loop.
    try {
      while (true) {
        // Get the next token.  Catch invalid input and output it
        // with minimal formatting, also catch end of input and
        // exit the loop.
        try {
          token = scanner.getNextToken();
          if (Scanner.DEBUG) {
            int currentEndPosition = scanner.getCurrentTokenEndPosition();
            int currentStartPosition = scanner.getCurrentTokenStartPosition();

            System.out.print(currentStartPosition + "," + currentEndPosition + ": ");
            System.out.println(scanner.toStringAction(token));
          }

          // Patch for line comment
          // See PR http://dev.eclipse.org/bugs/show_bug.cgi?id=23096
          if (token == ITerminalSymbols.TokenNameCOMMENT_LINE) {
            int length = scanner.currentPosition;
            loop : for (int index = length - 1; index >= 0; index--) {
              switch (scanner.source[index]) {
                case '\r' :
                case '\n' :
                  scanner.currentPosition--;
                  break;
                default :
                  break loop;
              }
            }
          }
        } catch (InvalidInputException e) {
          if (!handleInvalidToken(e)) {
            throw e;
          }
          token = 0;
        }
        if (token == Scanner.TokenNameEOF)
          break;

        /* ## MODIFYING the indentation level before generating new lines
        and indentation in the output string
        */

        // Removes all the indentations made by statements not followed by a block
        // except if the current token is ELSE, CATCH or if we are in a switch/case
        if (clearNonBlockIndents && (token != Scanner.TokenNameWHITESPACE)) {
          switch (token) {
            case TokenNameelse :
              if (constructionsCount > 0 && constructions[constructionsCount - 1] == TokenNameelse) {
                pendingNewLines = 1;
                specialElse = true;
              }
              indentationLevel += popInclusiveUntil(TokenNameif);
              break;
              //						case TokenNamecatch :
              //							indentationLevel += popInclusiveUntil(TokenNamecatch);
              //							break;
              //						case TokenNamefinally :
              //							indentationLevel += popInclusiveUntil(TokenNamecatch);
              //							break;
            case TokenNamewhile :
              if (nlicsToken == TokenNamedo) {
                indentationLevel += pop(TokenNamedo);
                break;
              }
            default :
              indentationLevel += popExclusiveUntilBlockOrCase();
              // clear until a CASE, DEFAULT or BLOCK is encountered.
              // Thus, the indentationLevel is correctly cleared either
              // in a switch/case statement or in any other situation.
          }
          clearNonBlockIndents = false;
        }
        // returns to the indentation level created by the SWITCH keyword
        // if the current token is a CASE or a DEFAULT
        if (token == TokenNamecase || token == TokenNamedefault) {
          indentationLevel += pop(TokenNamecase);
        }
        //				if (token == Scanner.TokenNamethrows) {
        //					inThrowsClause = true;
        //				}
        if ((token == Scanner.TokenNameclass // || token == Scanner.TokenNameinterface
        )
          && previousToken != Scanner.TokenNameDOT) {
          inClassOrInterfaceHeader = true;
        }

        /* ## APPEND newlines and indentations to the output string
        */
        // Do not add a new line between ELSE and IF, if the option elseIfOnSameLine is true.
        // Fix for 1ETLWPZ: IVJCOM:ALL - incorrect "else if" formatting
        //        if (pendingNewlineAfterParen
        //          && previousCompilableToken == TokenNameelse
        //          && token == TokenNameif
        //          && options.compactElseIfMode) {
        //          pendingNewlineAfterParen = false;
        //          pendingNewLines = 0;
        //          indentationLevel += pop(TokenNameelse);
        //          // because else if is now one single statement,
        //          // the indentation level after it is increased by one and not by 2
        //          // (else = 1 indent, if = 1 indent, but else if = 1 indent, not 2).
        //        }
        // Add a newline & indent to the formatted source string if
        // a for/if-else/while statement was scanned and there is no block
        // following it.
        pendingNewlineAfterParen =
          pendingNewlineAfterParen || (previousCompilableToken == TokenNameRPAREN && token == TokenNameLBRACE);
        if (pendingNewlineAfterParen && token != Scanner.TokenNameWHITESPACE) {
          pendingNewlineAfterParen = false;

          // Do to add a newline & indent sequence if the current token is an
          // open brace or a period or if the current token is a semi-colon and the
          // previous token is a close paren.
          // add a new line if a parenthesis belonging to a for() statement
          // has been closed and the current token is not an opening brace
          if (token != TokenNameLBRACE
            && !isComment(token) // to avoid adding new line between else and a comment
            && token != TokenNameDOT
            && !(previousCompilableToken == TokenNameRPAREN && token == TokenNameSEMICOLON)) {
            newLine(1);
            currentLineIndentationLevel = indentationLevel;
            pendingNewLines = 0;
            pendingSpace = false;
          } else {
            if (token == TokenNameLBRACE && options.newLineBeforeOpeningBraceMode) {
              newLine(1);
              if (constructionsCount > 0
                && constructions[constructionsCount - 1] != BLOCK
                && constructions[constructionsCount - 1] != NONINDENT_BLOCK) {
                currentLineIndentationLevel = indentationLevel - 1;
              } else {
                currentLineIndentationLevel = indentationLevel;
              }
              pendingNewLines = 0;
              pendingSpace = false;
            }
          }
        }
        if (token == TokenNameLBRACE
          && options.newLineBeforeOpeningBraceMode
          && constructionsCount > 0
          && constructions[constructionsCount - 1] == TokenNamedo) {
          newLine(1);
          currentLineIndentationLevel = indentationLevel - 1;
          pendingNewLines = 0;
          pendingSpace = false;
        }
        // see PR 1G5G8EC
        if (token == TokenNameLBRACE && inThrowsClause) {
          inThrowsClause = false;
          if (options.newLineBeforeOpeningBraceMode) {
            newLine(1);
            currentLineIndentationLevel = indentationLevel;
            pendingNewLines = 0;
            pendingSpace = false;
          }
        }
        // see PR 1G5G82G
        if (token == TokenNameLBRACE && inClassOrInterfaceHeader) {
          inClassOrInterfaceHeader = false;
          if (options.newLineBeforeOpeningBraceMode) {
            newLine(1);
            currentLineIndentationLevel = indentationLevel;
            pendingNewLines = 0;
            pendingSpace = false;
          }
        }
        // Add pending new lines to the formatted source string.
        // Note: pending new lines are not added if the current token
        // is a single line comment or whitespace.
        // if the comment is between parenthesis, there is no blank line preservation
        // (if it's a one-line comment, a blank line is added after it).
        if (((pendingNewLines > 0 && (!isComment(token)))
          || (newLinesInWhitespace > 0 && (openParenthesisCount <= 1 && isComment(token)))
          || (previousCompilableToken == TokenNameLBRACE && token == TokenNameRBRACE))
          && token != Scanner.TokenNameWHITESPACE) {

          // Do not add newline & indent between an adjoining close brace and
          // close paren.  Anonymous inner classes may use this form.
          boolean closeBraceAndCloseParen = previousToken == TokenNameRBRACE && token == TokenNameRPAREN;

          // OPTION (NewLineInCompoundStatement): do not add newline & indent
          // between close brace and else, (do) while, catch, and finally if
          // newlineInCompoundStatement is true.
          boolean nlicsOption =
            previousToken == TokenNameRBRACE
              && !options.newlineInControlStatementMode
              && (token == TokenNameelse || (token == TokenNamewhile && nlicsToken == TokenNamedo));
          //								|| token == TokenNamecatch
          //								|| token == TokenNamefinally);

          // Do not add a newline & indent between a close brace and semi-colon.
          boolean semiColonAndCloseBrace = previousToken == TokenNameRBRACE && token == TokenNameSEMICOLON;

          // Do not add a new line & indent between a multiline comment and a opening brace
          boolean commentAndOpenBrace = previousToken == Scanner.TokenNameCOMMENT_BLOCK && token == TokenNameLBRACE;

          // Do not add a newline & indent between a close brace and a colon (in array assignments, for example).
          boolean commaAndCloseBrace = previousToken == TokenNameRBRACE && token == TokenNameCOMMA;

          // Add a newline and indent, if appropriate.
          if (specialElse
            || (!commentAndOpenBrace && !closeBraceAndCloseParen && !nlicsOption && !semiColonAndCloseBrace && !commaAndCloseBrace)) {

            // if clearAllBlankLinesMode=false, leaves the blank lines
            // inserted by the user
            // if clearAllBlankLinesMode=true, removes all of then
            // and insert only blank lines required by the formatting.
            if (!options.clearAllBlankLinesMode) {
              //  (isComment(token))
              pendingNewLines = (pendingNewLines < newLinesInWhitespace) ? newLinesInWhitespace : pendingNewLines;
              pendingNewLines = (pendingNewLines > 2) ? 2 : pendingNewLines;
            }
            if (previousCompilableToken == TokenNameLBRACE && token == TokenNameRBRACE) {
              containsOpenCloseBraces = true;
              indentationLevelForOpenCloseBraces = currentLineIndentationLevel;
              if (isComment(previousToken)) {
                newLine(pendingNewLines);
              } else {
                /*  if (!(constructionsCount > 1
                        && constructions[constructionsCount-1] == NONINDENT_BLOCK
                        && (constructions[constructionsCount-2] == TokenNamefor 
                         || constructions[constructionsCount-2] == TokenNamewhile))) {*/
                if (options.newLineInEmptyBlockMode) {
                  if (inArrayAssignment) {
                    newLine(1); // array assigment with an empty block
                  } else {
                    newLine(pendingNewLines);
                  }
                }
                // }
              }
            } else {
              // see PR 1FKKC3U: LFCOM:WINNT - Format problem with a comment before the ';'
              if (!((previousToken == Scanner.TokenNameCOMMENT_BLOCK || previousToken == Scanner.TokenNameCOMMENT_PHPDOC)
                && token == TokenNameSEMICOLON)) {
                newLine(pendingNewLines);
              }
            }
            if (((previousCompilableToken == TokenNameSEMICOLON)
              || (previousCompilableToken == TokenNameLBRACE)
              || (previousCompilableToken == TokenNameRBRACE)
              || (isComment(previousToken)))
              && (token == TokenNameRBRACE)) {
              indentationOffset = -1;
              indentationLevel += popExclusiveUntilBlock();
            }
            if (previousToken == Scanner.TokenNameCOMMENT_LINE && inAssignment) {
              // PR 1FI5IPO
              currentLineIndentationLevel++;
            } else {
              currentLineIndentationLevel = indentationLevel + indentationOffset;
            }
            pendingSpace = false;
            indentationOffset = 0;
          }
          pendingNewLines = 0;
          newLinesInWhitespace = 0;
          specialElse = false;

          if (nlicsToken == TokenNamedo && token == TokenNamewhile) {
            nlicsToken = 0;
          }
        }
        switch (token) {
          case TokenNameDOLLAR_LBRACE :
            dollarBraceCount++;
            break;
          case TokenNameelse :
            //				case TokenNamefinally :
            expectingOpenBrace = true;
            pendingNewlineAfterParen = true;
            indentationLevel += pushControlStatement(token);
            break;
          case TokenNamecase :
          case TokenNamedefault :
            if (tokenBeforeColonCount == tokenBeforeColon.length) {
              System.arraycopy(
                tokenBeforeColon,
                0,
                (tokenBeforeColon = new int[tokenBeforeColonCount * 2]),
                0,
                tokenBeforeColonCount);
            }
            tokenBeforeColon[tokenBeforeColonCount++] = TokenNamecase;
            indentationLevel += pushControlStatement(TokenNamecase);
            break;
          case TokenNameQUESTION :
            if (tokenBeforeColonCount == tokenBeforeColon.length) {
              System.arraycopy(
                tokenBeforeColon,
                0,
                (tokenBeforeColon = new int[tokenBeforeColonCount * 2]),
                0,
                tokenBeforeColonCount);
            }
            tokenBeforeColon[tokenBeforeColonCount++] = token;
            break;
          case TokenNameswitch :
          case TokenNamefor :
          case TokenNameif :
          case TokenNamewhile :
            if (openParenthesisCount == openParenthesis.length) {
              System.arraycopy(openParenthesis, 0, (openParenthesis = new int[openParenthesisCount * 2]), 0, openParenthesisCount);
            }
            openParenthesis[openParenthesisCount++] = 0;
            expectingOpenBrace = true;

            indentationLevel += pushControlStatement(token);
            break;
            //					case TokenNametry :
            //						pendingNewlineAfterParen = true;
            //					case TokenNamecatch :
            //						// several CATCH statements can be contiguous.
            //						// a CATCH is encountered pop until first CATCH (if a CATCH follows a TRY it works the same way,
            //						// as CATCH and TRY are the same token in the stack).
            //						expectingOpenBrace = true;
            //						indentationLevel += pushControlStatement(TokenNamecatch);
            //						break;

          case TokenNamedo :
            expectingOpenBrace = true;
            indentationLevel += pushControlStatement(token);
            nlicsToken = token;
            break;
          case TokenNamenew :
            break;
          case TokenNameLPAREN :
            //						if (previousToken == TokenNamesynchronized) {
            //							indentationLevel += pushControlStatement(previousToken);
            //						} else {
            // Put a space between the previous and current token if the
            // previous token was not a keyword, open paren, logical
            // compliment (eg: !), semi-colon, open brace, close brace,
            // super, or this.
            if (previousCompilableToken != TokenNameLBRACKET
              && previousToken != TokenNameIdentifier
              && previousToken != 0
              && previousToken != TokenNameNOT
              && previousToken != TokenNameLPAREN
              && previousToken != TokenNameTWIDDLE
              && previousToken != TokenNameSEMICOLON
              && previousToken != TokenNameLBRACE
              && previousToken != TokenNameRBRACE) {
              //								&& previousToken != TokenNamesuper
              //								&& previousToken != TokenNamethis) {
              space();
            }
            // If in a for/if/while statement, increase the parenthesis count
            // for the current openParenthesisCount
            // else increase the count for stand alone parenthesis.
            if (openParenthesisCount > 0)
              openParenthesis[openParenthesisCount - 1]++;
            else
              openParenthesis[0]++;

            pendingSpace = false;
            //S			}
            break;
          case TokenNameRPAREN :

            // Decrease the parenthesis count
            // if there is no more unclosed parenthesis,
            // a new line and indent may be append (depending on the next token).
            if ((openParenthesisCount > 1) && (openParenthesis[openParenthesisCount - 1] > 0)) {
              openParenthesis[openParenthesisCount - 1]--;
              if (openParenthesis[openParenthesisCount - 1] <= 0) {
                pendingNewlineAfterParen = true;
                inAssignment = false;
                openParenthesisCount--;
              }
            } else {
              openParenthesis[0]--;
            }
            pendingSpace = false;
            break;
          case TokenNameLBRACE :
            if ((previousCompilableToken == TokenNameRBRACKET) || (previousCompilableToken == TokenNameEQUAL)) {
              //                  if (previousCompilableToken == TokenNameRBRACKET) {
              inArrayAssignment = true;
              inAssignment = false;
            }
            if (inArrayAssignment) {
              indentationLevel += pushBlock();
            } else {
              // Add new line and increase indentation level after open brace.
              pendingNewLines = 1;
              indentationLevel += pushBlock();
            }
            break;
          case TokenNameRBRACE :
            if (dollarBraceCount > 0) {
              dollarBraceCount--;
              break;
            }
            if (previousCompilableToken == TokenNameRPAREN) {
              pendingSpace = false;
            }
            if (inArrayAssignment) {
              inArrayAssignment = false;
              pendingNewLines = 1;
              indentationLevel += popInclusiveUntilBlock();
            } else {
              pendingNewLines = 1;
              indentationLevel += popInclusiveUntilBlock();

              if (previousCompilableToken == TokenNameRPAREN) {
                // fix for 1FGDDV6: LFCOM:WIN98 - Weird splitting on message expression
                currentLineBuffer.append(options.lineSeparatorSequence);
                increaseLineDelta(options.lineSeparatorSequence.length);
              }
              if (constructionsCount > 0) {
                switch (constructions[constructionsCount - 1]) {
                  case TokenNamefor :
                    //indentationLevel += popExclusiveUntilBlock();
                    //break;
                  case TokenNameswitch :
                  case TokenNameif :
                  case TokenNameelse :
                    //									case TokenNametry :
                    //									case TokenNamecatch :
                    //									case TokenNamefinally :
                  case TokenNamewhile :
                  case TokenNamedo :
                    //									case TokenNamesynchronized :
                    clearNonBlockIndents = true;
                  default :
                    break;
                }
              }
            }
            break;
          case TokenNameLBRACKET :
            openBracketCount++;
            pendingSpace = false;
            break;
          case TokenNameRBRACKET :
            openBracketCount -= (openBracketCount > 0) ? 1 : 0;
            // if there is no left bracket to close, the right bracket is ignored.
            pendingSpace = false;
            break;
          case TokenNameCOMMA :
          case TokenNameDOT :
            pendingSpace = false;
            break;
          case TokenNameSEMICOLON :

            // Do not generate line terminators in the definition of
            // the for statement.
            // if not in this case, jump a line and reduce indentation after the brace
            // if the block it closes belongs to a conditional statement (if, while, do...).
            if (openParenthesisCount <= 1) {
              pendingNewLines = 1;
              if (expectingOpenBrace) {
                clearNonBlockIndents = true;
                expectingOpenBrace = false;
              }
            }
            inAssignment = false;
            pendingSpace = false;
            break;
          case TokenNamePLUS_PLUS :
          case TokenNameMINUS_MINUS :

            // Do not put a space between a post-increment/decrement
            // and the identifier being modified.
            if (previousToken == TokenNameIdentifier || previousToken == TokenNameRBRACKET) {
              pendingSpace = false;
            }
            break;
          case TokenNamePLUS : // previously ADDITION
          case TokenNameMINUS :

            // Handle the unary operators plus and minus via a flag
            if (!isLiteralToken(previousToken)
              && previousToken != TokenNameIdentifier
              && previousToken != TokenNameRPAREN
              && previousToken != TokenNameRBRACKET) {
              unarySignModifier = 1;
            }
            break;
          case TokenNameCOLON :
            // In a switch/case statement, add a newline & indent
            // when a colon is encountered.
            if (tokenBeforeColonCount > 0) {
              if (tokenBeforeColon[tokenBeforeColonCount - 1] == TokenNamecase) {
                pendingNewLines = 1;
              }
              tokenBeforeColonCount--;
            }
            break;
          case TokenNameEQUAL :
            inAssignment = true;
            break;
          case Scanner.TokenNameCOMMENT_LINE :
            pendingNewLines = 1;
            if (inAssignment) {
              currentLineIndentationLevel++;
            }
            break; // a line is always inserted after a one-line comment
          case Scanner.TokenNameCOMMENT_PHPDOC :
          case Scanner.TokenNameCOMMENT_BLOCK :
            currentCommentOffset = getCurrentCommentOffset();
            pendingNewLines = 1;
            break;
          case Scanner.TokenNameWHITESPACE :

            // Count the number of line terminators in the whitespace so
            // line spacing can be preserved near comments.
            char[] source = scanner.source;
            newLinesInWhitespace = 0;
            for (int i = scanner.startPosition, max = scanner.currentPosition; i < max; i++) {
              if (source[i] == '\r') {
                if (i < max - 1) {
                  if (source[++i] == '\n') {
                    newLinesInWhitespace++;
                  } else {
                    newLinesInWhitespace++;
                  }
                } else {
                  newLinesInWhitespace++;
                }
              } else if (source[i] == '\n') {
                newLinesInWhitespace++;
              }
            }
            increaseLineDelta(scanner.startPosition - scanner.currentPosition);
            break;
            //          case TokenNameHTML :
            //            // Add the next token to the formatted source string.
            //            // outputCurrentToken(token);
            //            int startPosition = scanner.startPosition;
            //            flushBuffer();
            //            for (int i = startPosition, max = scanner.currentPosition; i < max; i++) {
            //              char currentCharacter = scanner.source[i];
            //              updateMappedPositions(i);
            //              currentLineBuffer.append(currentCharacter);
            //            }
            //            break;
          default :
            if ((token == TokenNameIdentifier) || isLiteralToken(token)) {
              //							|| token == TokenNamesuper
              //							|| token == TokenNamethis) {

              // Do not put a space between a unary operator
              // (eg: ++, --, +, -) and the identifier being modified.
              if (previousToken == TokenNamePLUS_PLUS
                || previousToken == TokenNameMINUS_MINUS
                || (previousToken == TokenNamePLUS && unarySignModifier > 0)
                || (previousToken == TokenNameMINUS && unarySignModifier > 0)) {
                pendingSpace = false;
              }
              unarySignModifier = 0;
            }
            break;
        }
        // Do not output whitespace tokens.
        if (token != Scanner.TokenNameWHITESPACE) {

          /* Add pending space to the formatted source string.
          Do not output a space under the following circumstances:
          1) this is the first pass
          2) previous token is an open paren
          3) previous token is a period
          4) previous token is the logical compliment (eg: !)
          5) previous token is the bitwise compliment (eg: ~)
          6) previous token is the open bracket (eg: [)
          7) in an assignment statement, if the previous token is an 
          open brace or the current token is a close brace
          8) previous token is a single line comment
          */
          boolean openAndCloseBrace = previousCompilableToken == TokenNameLBRACE && token == TokenNameRBRACE;

          if (pendingSpace
            && insertSpaceAfter(previousToken)
            && !(inAssignment && (previousToken == TokenNameLBRACE || token == TokenNameRBRACE))
            && previousToken != Scanner.TokenNameCOMMENT_LINE) {
            if ((!(options.compactAssignmentMode && token == TokenNameEQUAL)) && !openAndCloseBrace)
              space();
          }
          // Add the next token to the formatted source string.
          outputCurrentToken(token);
          if (token == Scanner.TokenNameCOMMENT_LINE && openParenthesisCount > 1) {
            pendingNewLines = 0;
            currentLineBuffer.append(options.lineSeparatorSequence);
            increaseLineDelta(options.lineSeparatorSequence.length);
          }
          pendingSpace = true;
        }
        // Whitespace tokens do not need to be remembered.
        if (token != Scanner.TokenNameWHITESPACE) {
          previousToken = token;
          if (token != Scanner.TokenNameCOMMENT_BLOCK
            && token != Scanner.TokenNameCOMMENT_LINE
            && token != Scanner.TokenNameCOMMENT_PHPDOC) {
            previousCompilableToken = token;
          }
        }
      }
      output(copyRemainingSource());
      flushBuffer();
      // dump the last token of the source in the formatted output.
    } catch (InvalidInputException e) {
      output(copyRemainingSource());
      flushBuffer();
      // dump the last token of the source in the formatted output.
    }
  }

  /** 
   * Formats the char array <code>sourceString</code>,
   * and returns a string containing the formatted version.
   * @return the formatted ouput.
   */
  public String formatSourceString(String sourceString) {
    char[] sourceChars = sourceString.toCharArray();
    formattedSource = new StringBuffer(sourceChars.length);
    scanner.setSource(sourceChars);
    format();
    return formattedSource.toString();
  }

  /** 
   * Formats the char array <code>sourceString</code>,
   * and returns a string containing the formatted version.
   * @param string the string to format
   * @param indentationLevel the initial indentation level
   * @return the formatted ouput.
   */
  public String format(String string, int indentationLevel) {
    return format(string, indentationLevel, (int[]) null);
  }

  /** 
   * Formats the char array <code>sourceString</code>,
   * and returns a string containing the formatted version.
   * The positions array is modified to contain the mapped positions.
   * @param string the string to format
   * @param indentationLevel the initial indentation level
   * @param positions the array of positions to map
   * @return the formatted ouput.
   */
  public String format(String string, int indentationLevel, int[] positions) {
    return this.format(string, indentationLevel, positions, null);
  }

  public String format(String string, int indentationLevel, int[] positions, String lineSeparator) {
    if (lineSeparator != null) {
      this.options.setLineSeparator(lineSeparator);
    }
    if (positions != null) {
      this.setPositionsToMap(positions);
      this.setInitialIndentationLevel(indentationLevel);
      String formattedString = this.formatSourceString(string);
      int[] mappedPositions = this.getMappedPositions();
      System.arraycopy(mappedPositions, 0, positions, 0, positions.length);
      return formattedString;
    } else {
      this.setInitialIndentationLevel(indentationLevel);
      return this.formatSourceString(string);
    }
  }
  /** 
   * Formats the char array <code>sourceString</code>,
   * and returns a string containing the formatted version. The initial indentation level is 0.
   * @param string the string to format
   * @return the formatted ouput.
   */
  public String format(String string) {
    return this.format(string, 0, (int[]) null);
  }

  /** 
   * Formats a given source string, starting indenting it at a particular 
   * depth and using the given options
   * 
   * @deprecated backport 1.0 internal functionality
   */
  public static String format(String sourceString, int initialIndentationLevel, ConfigurableOption[] options) {
    CodeFormatter formatter = new CodeFormatter(options);
    formatter.setInitialIndentationLevel(initialIndentationLevel);
    return formatter.formatSourceString(sourceString);
  }

  /**
   * Returns the number of characters and tab char between the beginning of the line
   * and the beginning of the comment.
   */
  private int getCurrentCommentOffset() {
    int linePtr = scanner.linePtr;
    // if there is no beginning of line, return 0.
    if (linePtr < 0)
      return 0;
    int offset = 0;
    int beginningOfLine = scanner.lineEnds[linePtr];
    int currentStartPosition = scanner.startPosition;
    char[] source = scanner.source;

    // find the position of the beginning of the line containing the comment
    while (beginningOfLine > currentStartPosition) {
      if (linePtr > 0) {
        beginningOfLine = scanner.lineEnds[--linePtr];
      } else {
        beginningOfLine = 0;
        break;
      }
    }
    for (int i = currentStartPosition - 1; i >= beginningOfLine; i--) {
      char currentCharacter = source[i];
      switch (currentCharacter) {
        case '\t' :
          offset += options.tabSize;
          break;
        case ' ' :
          offset++;
          break;
        case '\r' :
        case '\n' :
          break;
        default :
          return offset;
      }
    }
    return offset;
  }

  /**
   * Returns an array of descriptions for the configurable options.
   * The descriptions may be changed and passed back to a different
   * compiler.
   * 
   * @deprecated backport 1.0 internal functionality
   */
  public static ConfigurableOption[] getDefaultOptions(Locale locale) {
    String componentName = CodeFormatter.class.getName();
    FormatterOptions options = new FormatterOptions();
    return new ConfigurableOption[] { new ConfigurableOption(componentName, "newline.openingBrace", locale, options.newLineBeforeOpeningBraceMode ? 0 : 1), //$NON-NLS-1$
      new ConfigurableOption(componentName, "newline.controlStatement", locale, options.newlineInControlStatementMode ? 0 : 1), //$NON-NLS-1$
      new ConfigurableOption(componentName, "newline.clearAll", locale, options.clearAllBlankLinesMode ? 0 : 1), //$NON-NLS-1$
      //      new ConfigurableOption(componentName, "newline.elseIf", locale, options.compactElseIfMode ? 0 : 1), //$NON-NLS-1$
      new ConfigurableOption(componentName, "newline.emptyBlock", locale, options.newLineInEmptyBlockMode ? 0 : 1), //$NON-NLS-1$
      new ConfigurableOption(componentName, "line.split", locale, options.maxLineLength), //$NON-NLS-1$
      new ConfigurableOption(componentName, "style.compactAssignment", locale, options.compactAssignmentMode ? 0 : 1), //$NON-NLS-1$
      new ConfigurableOption(componentName, "tabulation.char", locale, options.indentWithTab ? 0 : 1), //$NON-NLS-1$
      new ConfigurableOption(componentName, "tabulation.size", locale, options.tabSize) //$NON-NLS-1$
    };
  }

  /**
   * Returns the array of mapped positions.
   * Returns null is no positions have been set.
   * @return int[]
   * @deprecated There is no need to retrieve the mapped positions anymore.
   */
  public int[] getMappedPositions() {
    return mappedPositions;
  }

  /**
   * Returns the priority of the token given as argument<br>
   * The most prioritary the token is, the smallest the return value is.
   * @return the priority of <code>token</code>
   * @param token the token of which the priority is requested
   */
  private static int getTokenPriority(int token) {
    switch (token) {
      case TokenNameextends :
        //			case TokenNameimplements :
        //			case TokenNamethrows :
        return 10;
      case TokenNameSEMICOLON : // ;
        return 20;
      case TokenNameCOMMA : // ,
        return 25;
      case TokenNameEQUAL : // =
        return 30;
      case TokenNameAND_AND : // && 
      case TokenNameOR_OR : // || 
        return 40;
      case TokenNameQUESTION : // ? 
      case TokenNameCOLON : // :
        return 50; // it's better cutting on ?: than on ;
      case TokenNameEQUAL_EQUAL : // == 
      case TokenNameEQUAL_EQUAL_EQUAL : // === 
      case TokenNameNOT_EQUAL : // != 
			case TokenNameNOT_EQUAL_EQUAL : // != 
        return 60;
      case TokenNameLESS : // < 
      case TokenNameLESS_EQUAL : // <= 
      case TokenNameGREATER : // > 
      case TokenNameGREATER_EQUAL : // >= 
        //			case TokenNameinstanceof : // instanceof
        return 70;
      case TokenNamePLUS : // + 
      case TokenNameMINUS : // - 
        return 80;
      case TokenNameMULTIPLY : // * 
      case TokenNameDIVIDE : // / 
      case TokenNameREMAINDER : // % 
        return 90;
      case TokenNameLEFT_SHIFT : // << 
      case TokenNameRIGHT_SHIFT : // >> 
        //			case TokenNameUNSIGNED_RIGHT_SHIFT : // >>> 
        return 100;
      case TokenNameAND : // &
      case TokenNameOR : // | 
      case TokenNameXOR : // ^ 
        return 110;
      case TokenNameMULTIPLY_EQUAL : // *= 
      case TokenNameDIVIDE_EQUAL : // /= 
      case TokenNameREMAINDER_EQUAL : // %= 
      case TokenNamePLUS_EQUAL : // += 
      case TokenNameMINUS_EQUAL : // -= 
      case TokenNameLEFT_SHIFT_EQUAL : // <<= 
      case TokenNameRIGHT_SHIFT_EQUAL : // >>= 
        //			case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>=
      case TokenNameAND_EQUAL : // &= 
      case TokenNameXOR_EQUAL : // ^= 
      case TokenNameOR_EQUAL : // |= 
        return 120;
      case TokenNameDOT : // .
        return 130;
      default :
        return Integer.MAX_VALUE;
    }
  }

  /**
   * Handles the exception raised when an invalid token is encountered.
   * Returns true if the exception has been handled, false otherwise.
   */
  private boolean handleInvalidToken(Exception e) {
    if (e.getMessage().equals(Scanner.INVALID_CHARACTER_CONSTANT)
      || e.getMessage().equals(Scanner.INVALID_CHAR_IN_STRING)
      || e.getMessage().equals(Scanner.INVALID_ESCAPE)) {
      return true;
    }
    return false;
  }

  private final void increaseGlobalDelta(int offset) {
    globalDelta += offset;
  }

  private final void increaseLineDelta(int offset) {
    lineDelta += offset;
  }

  private final void increaseSplitDelta(int offset) {
    splitDelta += offset;
  }

  /**
   * Returns true if a space has to be inserted after <code>operator</code>
   * false otherwise.
   */
  private boolean insertSpaceAfter(int token) {
    switch (token) {
      case TokenNameLPAREN :
      case TokenNameNOT :
      case TokenNameTWIDDLE :
      case TokenNameDOT :
      case 0 : // no token
      case TokenNameLBRACKET :
      case Scanner.TokenNameCOMMENT_LINE :
        return false;
      default :
        return true;
    }
  }

  /**
   * Returns true if a space has to be inserted before <code>operator</code>
   * false otherwise.<br>
   * Cannot be static as it uses the code formatter options
   * (to know if the compact assignment mode is on).
   */
  private boolean insertSpaceBefore(int token) {
    switch (token) {
      case TokenNameEQUAL :
        return (!options.compactAssignmentMode);
      default :
        return false;
    }
  }

  private static boolean isComment(int token) {
    boolean result =
      token == Scanner.TokenNameCOMMENT_BLOCK || token == Scanner.TokenNameCOMMENT_LINE || token == Scanner.TokenNameCOMMENT_PHPDOC;
    return result;
  }

  private static boolean isLiteralToken(int token) {
    boolean result = token == TokenNameIntegerLiteral
      //			|| token == TokenNameLongLiteral
    //			|| token == TokenNameFloatingPointLiteral
  || token == TokenNameDoubleLiteral
      //			|| token == TokenNameCharacterLiteral
  || token == TokenNameStringLiteral;
    return result;
  }

  /**
   * If the length of <code>oneLineBuffer</code> exceeds <code>maxLineLength</code>,
   * it is split and the result is dumped in <code>formattedSource</code>
   * @param newLineCount the number of new lines to append
   */
  private void newLine(int newLineCount) {

    // format current line
    splitDelta = 0;
    beginningOfLineIndex = formattedSource.length();
    String currentLine = currentLineBuffer.toString();
    if (containsOpenCloseBraces) {
      containsOpenCloseBraces = false;
      outputLine(currentLine, false, indentationLevelForOpenCloseBraces, 0, -1, null, 0);
      indentationLevelForOpenCloseBraces = currentLineIndentationLevel;
    } else {
      outputLine(currentLine, false, currentLineIndentationLevel, 0, -1, null, 0);
    }
    // dump line break(s)
    for (int i = 0; i < newLineCount; i++) {
      formattedSource.append(options.lineSeparatorSequence);
      increaseSplitDelta(options.lineSeparatorSequence.length);
    }
    // reset formatter for next line
    int currentLength = currentLine.length();
    currentLineBuffer = new StringBuffer(currentLength > maxLineSize ? maxLineSize = currentLength : maxLineSize);

    increaseGlobalDelta(splitDelta);
    increaseGlobalDelta(lineDelta);
    lineDelta = 0;
    currentLineIndentationLevel = initialIndentationLevel;
  }

  private String operatorString(int operator) {
    switch (operator) {
      case TokenNameextends :
        return "extends"; //$NON-NLS-1$

        //			case TokenNameimplements :
        //				return "implements"; //$NON-NLS-1$
        //
        //			case TokenNamethrows :
        //				return "throws"; //$NON-NLS-1$

      case TokenNameSEMICOLON : // ;
        return ";"; //$NON-NLS-1$

      case TokenNameCOMMA : // ,
        return ","; //$NON-NLS-1$

      case TokenNameEQUAL : // =
        return "="; //$NON-NLS-1$

      case TokenNameAND_AND : // && (15.22)
        return "&&"; //$NON-NLS-1$

      case TokenNameOR_OR : // || (15.23)
        return "||"; //$NON-NLS-1$

      case TokenNameQUESTION : // ? (15.24)
        return "?"; //$NON-NLS-1$

      case TokenNameCOLON : // : (15.24)
        return ":"; //$NON-NLS-1$

      case TokenNameCOLON_COLON : // : (15.24)
        return "::"; //$NON-NLS-1$

      case TokenNameEQUAL_EQUAL : // == (15.20, 15.20.1, 15.20.2, 15.20.3)
        return "=="; //$NON-NLS-1$

      case TokenNameEQUAL_EQUAL_EQUAL : // == (15.20, 15.20.1, 15.20.2, 15.20.3)
        return "==="; //$NON-NLS-1$

      case TokenNameEQUAL_GREATER : // -= (15.25.2)
        return "=>"; //$NON-NLS-1$				

      case TokenNameNOT_EQUAL : // != (15.20, 15.20.1, 15.20.2, 15.20.3)
        return "!="; //$NON-NLS-1$

			case TokenNameNOT_EQUAL_EQUAL : // != (15.20, 15.20.1, 15.20.2, 15.20.3)
				return "!=="; //$NON-NLS-1$
							
      case TokenNameLESS : // < (15.19.1)
        return "<"; //$NON-NLS-1$

      case TokenNameLESS_EQUAL : // <= (15.19.1)
        return "<="; //$NON-NLS-1$

      case TokenNameGREATER : // > (15.19.1)
        return ">"; //$NON-NLS-1$

      case TokenNameGREATER_EQUAL : // >= (15.19.1)
        return ">="; //$NON-NLS-1$

        //			case TokenNameinstanceof : // instanceof
        //				return "instanceof"; //$NON-NLS-1$

      case TokenNamePLUS : // + (15.17, 15.17.2)
        return "+"; //$NON-NLS-1$

      case TokenNameMINUS : // - (15.17.2)
        return "-"; //$NON-NLS-1$

      case TokenNameMULTIPLY : // * (15.16.1)
        return "*"; //$NON-NLS-1$

      case TokenNameDIVIDE : // / (15.16.2)
        return "/"; //$NON-NLS-1$

      case TokenNameREMAINDER : // % (15.16.3)
        return "%"; //$NON-NLS-1$

      case TokenNameLEFT_SHIFT : // << (15.18)
        return "<<"; //$NON-NLS-1$

      case TokenNameRIGHT_SHIFT : // >> (15.18)
        return ">>"; //$NON-NLS-1$

        //			case TokenNameUNSIGNED_RIGHT_SHIFT : // >>> (15.18)
        //				return ">>>"; //$NON-NLS-1$

      case TokenNameAND : // & (15.21, 15.21.1, 15.21.2)
        return "&"; //$NON-NLS-1$

      case TokenNameOR : // | (15.21, 15.21.1, 15.21.2)
        return "|"; //$NON-NLS-1$

      case TokenNameXOR : // ^ (15.21, 15.21.1, 15.21.2)
        return "^"; //$NON-NLS-1$

      case TokenNameMULTIPLY_EQUAL : // *= (15.25.2)
        return "*="; //$NON-NLS-1$

      case TokenNameDIVIDE_EQUAL : // /= (15.25.2)
        return "/="; //$NON-NLS-1$

      case TokenNameREMAINDER_EQUAL : // %= (15.25.2)
        return "%="; //$NON-NLS-1$

      case TokenNamePLUS_EQUAL : // += (15.25.2)
        return "+="; //$NON-NLS-1$

      case TokenNameMINUS_EQUAL : // -= (15.25.2)
        return "-="; //$NON-NLS-1$

      case TokenNameMINUS_GREATER : // -= (15.25.2)
        return "->"; //$NON-NLS-1$

      case TokenNameLEFT_SHIFT_EQUAL : // <<= (15.25.2)
        return "<<="; //$NON-NLS-1$

      case TokenNameRIGHT_SHIFT_EQUAL : // >>= (15.25.2)
        return ">>="; //$NON-NLS-1$

        //			case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>= (15.25.2)
        //				return ">>>="; //$NON-NLS-1$

      case TokenNameAND_EQUAL : // &= (15.25.2)
        return "&="; //$NON-NLS-1$

      case TokenNameXOR_EQUAL : // ^= (15.25.2)
        return "^="; //$NON-NLS-1$

      case TokenNameOR_EQUAL : // |= (15.25.2)
        return "|="; //$NON-NLS-1$

      case TokenNameDOT : // .
        return "."; //$NON-NLS-1$

      default :
        return ""; //$NON-NLS-1$
    }
  }

  /** 
   * Appends <code>stringToOutput</code> to the formatted output.<br>
   * If it contains \n, append a LINE_SEPARATOR and indent after it.
   */
  private void output(String stringToOutput) {
    char currentCharacter;
    for (int i = 0, max = stringToOutput.length(); i < max; i++) {
      currentCharacter = stringToOutput.charAt(i);
      if (currentCharacter != '\t') {
        currentLineBuffer.append(currentCharacter);
      }
    }
  }

  /** 
   * Appends <code>token</code> to the formatted output.<br>
   * If it contains <code>\n</code>, append a LINE_SEPARATOR and indent after it.
   */
  private void outputCurrentToken(int token) {
    char[] source = scanner.source;
    int startPosition = scanner.startPosition;

    switch (token) {
      case Scanner.TokenNameCOMMENT_PHPDOC :
      case Scanner.TokenNameCOMMENT_BLOCK :
      case Scanner.TokenNameCOMMENT_LINE :
        boolean endOfLine = false;
        int currentCommentOffset = getCurrentCommentOffset();
        int beginningOfLineSpaces = 0;
        endOfLine = false;
        currentCommentOffset = getCurrentCommentOffset();
        beginningOfLineSpaces = 0;
        boolean pendingCarriageReturn = false;
        for (int i = startPosition, max = scanner.currentPosition; i < max; i++) {
          char currentCharacter = source[i];
          updateMappedPositions(i);
          switch (currentCharacter) {
            case '\r' :
              pendingCarriageReturn = true;
              endOfLine = true;
              break;
            case '\n' :
              if (pendingCarriageReturn) {
                increaseGlobalDelta(options.lineSeparatorSequence.length - 2);
              } else {
                increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
              }
              pendingCarriageReturn = false;
              currentLineBuffer.append(options.lineSeparatorSequence);
              beginningOfLineSpaces = 0;
              endOfLine = true;
              break;
            case '\t' :
              if (pendingCarriageReturn) {
                pendingCarriageReturn = false;
                increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
                currentLineBuffer.append(options.lineSeparatorSequence);
                beginningOfLineSpaces = 0;
                endOfLine = true;
              }
              if (endOfLine) {
                // we remove a maximum of currentCommentOffset characters (tabs are converted to space numbers).
                beginningOfLineSpaces += options.tabSize;
                if (beginningOfLineSpaces > currentCommentOffset) {
                  currentLineBuffer.append(currentCharacter);
                } else {
                  increaseGlobalDelta(-1);
                }
              } else {
                currentLineBuffer.append(currentCharacter);
              }
              break;
            case ' ' :
              if (pendingCarriageReturn) {
                pendingCarriageReturn = false;
                increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
                currentLineBuffer.append(options.lineSeparatorSequence);
                beginningOfLineSpaces = 0;
                endOfLine = true;
              }
              if (endOfLine) {
                // we remove a maximum of currentCommentOffset characters (tabs are converted to space numbers).
                beginningOfLineSpaces++;
                if (beginningOfLineSpaces > currentCommentOffset) {
                  currentLineBuffer.append(currentCharacter);
                } else {
                  increaseGlobalDelta(-1);
                }
              } else {
                currentLineBuffer.append(currentCharacter);
              }
              break;
            default :
              if (pendingCarriageReturn) {
                pendingCarriageReturn = false;
                increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
                currentLineBuffer.append(options.lineSeparatorSequence);
                beginningOfLineSpaces = 0;
                endOfLine = true;
              } else {
                beginningOfLineSpaces = 0;
                currentLineBuffer.append(currentCharacter);
                endOfLine = false;
              }
          }
        }
        updateMappedPositions(scanner.currentPosition - 1);
        multipleLineCommentCounter++;
        break;
      default :
        for (int i = startPosition, max = scanner.currentPosition; i < max; i++) {
          char currentCharacter = source[i];
          updateMappedPositions(i);
          currentLineBuffer.append(currentCharacter);
        }
    }
  }

  /**
   * Outputs <code>currentString</code>:<br>
   * <ul><li>If its length is < maxLineLength, output
   * <li>Otherwise it is split.</ul>
   * @param currentString string to output
   * @param preIndented whether the string to output was pre-indented
   * @param depth number of indentation to put in front of <code>currentString</code>
   * @param operator value of the operator belonging to <code>currentString</code>.
   */
  private void outputLine(
    String currentString,
    boolean preIndented,
    int depth,
    int operator,
    int substringIndex,
    int[] startSubstringIndexes,
    int offsetInGlobalLine) {

    boolean emptyFirstSubString = false;
    String operatorString = operatorString(operator);
    boolean placeOperatorBehind = !breakLineBeforeOperator(operator);
    boolean placeOperatorAhead = !placeOperatorBehind;

    // dump prefix operator?
    if (placeOperatorAhead) {
      if (!preIndented) {
        dumpTab(depth);
        preIndented = true;
      }
      if (operator != 0) {
        if (insertSpaceBefore(operator)) {
          formattedSource.append(' ');
          increaseSplitDelta(1);
        }
        formattedSource.append(operatorString);
        increaseSplitDelta(operatorString.length());

        if (insertSpaceAfter(operator) //			&& operator != TokenNameimplements
        && operator != TokenNameextends) {
          //			&& operator != TokenNamethrows) {
          formattedSource.append(' ');
          increaseSplitDelta(1);
        }
      }
    }
    SplitLine splitLine = null;
    if (options.maxLineLength == 0
      || getLength(currentString, depth) < options.maxLineLength
      || (splitLine = split(currentString, offsetInGlobalLine)) == null) {

      // depending on the type of operator, outputs new line before of after dumping it
      // indent before postfix operator
      // indent also when the line cannot be split
      if (operator == TokenNameextends) {
        //				|| operator == TokenNameimplements
        //				|| operator == TokenNamethrows) {
        formattedSource.append(' ');
        increaseSplitDelta(1);
      }
      if (placeOperatorBehind) {
        if (!preIndented) {
          dumpTab(depth);
        }
      }
      int max = currentString.length();
      if (multipleLineCommentCounter != 0) {
        try {
          BufferedReader reader = new BufferedReader(new StringReader(currentString));
          String line = reader.readLine();
          while (line != null) {
            updateMappedPositionsWhileSplitting(
              beginningOfLineIndex,
              beginningOfLineIndex + line.length() + options.lineSeparatorSequence.length);
            formattedSource.append(line);
            beginningOfLineIndex = beginningOfLineIndex + line.length();
            if ((line = reader.readLine()) != null) {
              formattedSource.append(options.lineSeparatorSequence);
              beginningOfLineIndex += options.lineSeparatorSequence.length;
              dumpTab(currentLineIndentationLevel);
            }
          }
          reader.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      } else {
        updateMappedPositionsWhileSplitting(beginningOfLineIndex, beginningOfLineIndex + max);
        for (int i = 0; i < max; i++) {
          char currentChar = currentString.charAt(i);
          switch (currentChar) {
            case '\r' :
              break;
            case '\n' :
              if (i != max - 1) {
                // fix for 1FFYL5C: LFCOM:ALL - Incorrect indentation when split with a comment inside a condition
                // a substring cannot end with a lineSeparatorSequence,
                // except if it has been added by format() after a one-line comment
                formattedSource.append(options.lineSeparatorSequence);

                // 1FGDDV6: LFCOM:WIN98 - Weird splitting on message expression
                dumpTab(depth - 1);
              }
              break;
            default :
              formattedSource.append(currentChar);
          }
        }
      }
      // update positions inside the mappedPositions table
      if (substringIndex != -1) {
        if (multipleLineCommentCounter == 0) {
          int startPosition = beginningOfLineIndex + startSubstringIndexes[substringIndex];
          updateMappedPositionsWhileSplitting(startPosition, startPosition + max);
        }

        // compute the splitDelta resulting with the operator and blank removal
        if (substringIndex + 1 != startSubstringIndexes.length) {
          increaseSplitDelta(startSubstringIndexes[substringIndex] + max - startSubstringIndexes[substringIndex + 1]);
        }
      }
      // dump postfix operator?
      if (placeOperatorBehind) {
        if (insertSpaceBefore(operator)) {
          formattedSource.append(' ');
          if (operator != 0) {
            increaseSplitDelta(1);
          }
        }
        formattedSource.append(operatorString);
        if (operator != 0) {
          increaseSplitDelta(operatorString.length());
        }
      }
      return;
    }
    // fix for 1FG0BA3: LFCOM:WIN98 - Weird splitting on interfaces
    // extends has to stand alone on a line when currentString has been split.
    if (options.maxLineLength != 0 && splitLine != null && (operator == TokenNameextends)) {
      //				|| operator == TokenNameimplements
      //				|| operator == TokenNamethrows)) {
      formattedSource.append(options.lineSeparatorSequence);
      increaseSplitDelta(options.lineSeparatorSequence.length);
      dumpTab(depth + 1);
    } else {
      if (operator == TokenNameextends) {
        //				|| operator == TokenNameimplements
        //				|| operator == TokenNamethrows) {
        formattedSource.append(' ');
        increaseSplitDelta(1);
      }
    }
    // perform actual splitting
    String result[] = splitLine.substrings;
    int[] splitOperators = splitLine.operators;

    if (result[0].length() == 0) {
      // when the substring 0 is null, the substring 1 is correctly indented.
      depth--;
      emptyFirstSubString = true;
    }
    // the operator going in front of the result[0] string is the operator parameter
    for (int i = 0, max = result.length; i < max; i++) {
      // the new depth is the current one if this is the first substring,
      // the current one + 1 otherwise.
      // if the substring is a comment, use the current indentation Level instead of the depth
      // (-1 because the ouputline increases depth).
      // (fix for 1FFC72R: LFCOM:ALL - Incorrect line split in presence of line comments)
      String currentResult = result[i];

      if (currentResult.length() != 0 || splitOperators[i] != 0) {
          int newDepth = (currentResult.startsWith("/*") //$NON-NLS-1$
    || currentResult.startsWith("//")) //$NON-NLS-1$ 
  ? indentationLevel - 1 : depth;
        outputLine(
          currentResult,
          i == 0 || (i == 1 && emptyFirstSubString) ? preIndented : false,
          i == 0 ? newDepth : newDepth + 1,
          splitOperators[i],
          i,
          splitLine.startSubstringsIndexes,
          currentString.indexOf(currentResult));
        if (i != max - 1) {
          formattedSource.append(options.lineSeparatorSequence);
          increaseSplitDelta(options.lineSeparatorSequence.length);
        }
      }
    }
    if (result.length == splitOperators.length - 1) {
      int lastOperator = splitOperators[result.length];
      String lastOperatorString = operatorString(lastOperator);
      formattedSource.append(options.lineSeparatorSequence);
      increaseSplitDelta(options.lineSeparatorSequence.length);

      if (breakLineBeforeOperator(lastOperator)) {
        dumpTab(depth + 1);
        if (lastOperator != 0) {
          if (insertSpaceBefore(lastOperator)) {
            formattedSource.append(' ');
            increaseSplitDelta(1);
          }
          formattedSource.append(lastOperatorString);
          increaseSplitDelta(lastOperatorString.length());

          if (insertSpaceAfter(lastOperator) //					&& lastOperator != TokenNameimplements
            && lastOperator != TokenNameextends) {
            //					&& lastOperator != TokenNamethrows) {
            formattedSource.append(' ');
            increaseSplitDelta(1);
          }
        }
      }
    }
    if (placeOperatorBehind) {
      if (insertSpaceBefore(operator)) {
        formattedSource.append(' ');
        increaseSplitDelta(1);
      }
      formattedSource.append(operatorString);
      //increaseSplitDelta(operatorString.length());
    }
  }

  /**
   * Pops the top statement of the stack if it is <code>token</code>
   */
  private int pop(int token) {
    int delta = 0;
    if ((constructionsCount > 0) && (constructions[constructionsCount - 1] == token)) {
      delta--;
      constructionsCount--;
    }
    return delta;
  }

  /**
   * Pops the top statement of the stack if it is a <code>BLOCK</code> or a <code>NONINDENT_BLOCK</code>.
   */
  private int popBlock() {
    int delta = 0;
    if ((constructionsCount > 0)
      && ((constructions[constructionsCount - 1] == BLOCK) || (constructions[constructionsCount - 1] == NONINDENT_BLOCK))) {
      if (constructions[constructionsCount - 1] == BLOCK)
        delta--;
      constructionsCount--;
    }
    return delta;
  }

  /**
   * Pops elements until the stack is empty or the top element is <code>token</code>.<br>
   * Does not remove <code>token</code> from the stack.
   * @param token the token to be left as the top of the stack
   */
  private int popExclusiveUntil(int token) {
    int delta = 0;
    int startCount = constructionsCount;
    for (int i = startCount - 1; i >= 0 && constructions[i] != token; i--) {
      if (constructions[i] != NONINDENT_BLOCK)
        delta--;
      constructionsCount--;
    }
    return delta;
  }

  /**
   * Pops elements until the stack is empty or the top element is
   * a <code>BLOCK</code> or a <code>NONINDENT_BLOCK</code>.<br>
   * Does not remove it from the stack.
   */
  private int popExclusiveUntilBlock() {
    int startCount = constructionsCount;
    int delta = 0;
    for (int i = startCount - 1; i >= 0 && constructions[i] != BLOCK && constructions[i] != NONINDENT_BLOCK; i--) {
      constructionsCount--;
      delta--;
    }
    return delta;
  }

  /**
   * Pops elements until the stack is empty or the top element is
   * a <code>BLOCK</code>, a <code>NONINDENT_BLOCK</code> or a <code>CASE</code>.<br>
   * Does not remove it from the stack.
   */
  private int popExclusiveUntilBlockOrCase() {
    int startCount = constructionsCount;
    int delta = 0;
    for (int i = startCount - 1;
      i >= 0 && constructions[i] != BLOCK && constructions[i] != NONINDENT_BLOCK && constructions[i] != TokenNamecase;
      i--) {
      constructionsCount--;
      delta--;
    }
    return delta;
  }

  /**
   * Pops elements until the stack is empty or the top element is <code>token</code>.<br>
   * Removes <code>token</code> from the stack too.
   * @param token the token to remove from the stack
   */
  private int popInclusiveUntil(int token) {
    int startCount = constructionsCount;
    int delta = 0;
    for (int i = startCount - 1; i >= 0 && constructions[i] != token; i--) {
      if (constructions[i] != NONINDENT_BLOCK)
        delta--;
      constructionsCount--;
    }
    if (constructionsCount > 0) {
      if (constructions[constructionsCount - 1] != NONINDENT_BLOCK)
        delta--;
      constructionsCount--;
    }
    return delta;
  }

  /**
   * Pops elements until the stack is empty or the top element is
   * a <code>BLOCK</code> or a <code>NONINDENT_BLOCK</code>.<br>
   * Does not remove it from the stack.
   */
  private int popInclusiveUntilBlock() {
    int startCount = constructionsCount;
    int delta = 0;
    for (int i = startCount - 1; i >= 0 && (constructions[i] != BLOCK && constructions[i] != NONINDENT_BLOCK); i--) {
      delta--;
      constructionsCount--;
    }
    if (constructionsCount > 0) {
      if (constructions[constructionsCount - 1] == BLOCK)
        delta--;
      constructionsCount--;
    }
    return delta;
  }

  /** 
   * Pushes a block in the stack.<br>
   * Pushes a <code>BLOCK</code> if the stack is empty or if the top element is a <code>BLOCK</code>,
   * pushes <code>NONINDENT_BLOCK</code> otherwise.
   * Creates a new bigger array if the current one is full.
   */
  private int pushBlock() {
    int delta = 0;
    if (constructionsCount == constructions.length)
      System.arraycopy(constructions, 0, (constructions = new int[constructionsCount * 2]), 0, constructionsCount);

    if ((constructionsCount == 0)
      || (constructions[constructionsCount - 1] == BLOCK)
      || (constructions[constructionsCount - 1] == NONINDENT_BLOCK)
      || (constructions[constructionsCount - 1] == TokenNamecase)) {
      delta++;
      constructions[constructionsCount++] = BLOCK;
    } else {
      constructions[constructionsCount++] = NONINDENT_BLOCK;
    }
    return delta;
  }

  /** 
   * Pushes <code>token</code>.<br>
   * Creates a new bigger array if the current one is full.
   */
  private int pushControlStatement(int token) {
    if (constructionsCount == constructions.length)
      System.arraycopy(constructions, 0, (constructions = new int[constructionsCount * 2]), 0, constructionsCount);
    constructions[constructionsCount++] = token;
    return 1;
  }

  private static boolean separateFirstArgumentOn(int currentToken) {
    //return (currentToken == TokenNameCOMMA || currentToken == TokenNameSEMICOLON);
    return currentToken != TokenNameif
      && currentToken != TokenNameLPAREN
      && currentToken != TokenNameNOT
      && currentToken != TokenNamewhile
      && currentToken != TokenNamefor
      && currentToken != TokenNameswitch;
  }

  /**
   * Set the positions to map. The mapped positions should be retrieved using the
   * getMappedPositions() method.
   * @param positions int[]
   * @deprecated Set the positions to map using the format(String, int, int[]) method.
   * 
   * @see #getMappedPositions()
   */
  public void setPositionsToMap(int[] positions) {
    positionsToMap = positions;
    lineDelta = 0;
    globalDelta = 0;
    mappedPositions = new int[positions.length];
  }

  /** 
   * Appends a space character to the current line buffer.
   */
  private void space() {
    currentLineBuffer.append(' ');
    increaseLineDelta(1);
  }

  /**
   * Splits <code>stringToSplit</code> on the top level token<br>
   * If there are several identical token at the same level,
   * the string is cut into many pieces.
   * @return an object containing the operator and all the substrings
   * or null if the string cannot be split
   */
  public SplitLine split(String stringToSplit) {
    return split(stringToSplit, 0);
  }

  /**
   * Splits <code>stringToSplit</code> on the top level token<br>
   * If there are several identical token at the same level,
   * the string is cut into many pieces.
   * @return an object containing the operator and all the substrings
   * or null if the string cannot be split
   */
  public SplitLine split(String stringToSplit, int offsetInGlobalLine) {
    /*
     * See http://dev.eclipse.org/bugs/show_bug.cgi?id=12540 and
     * http://dev.eclipse.org/bugs/show_bug.cgi?id=14387 
     */
    if (stringToSplit.indexOf("//$NON-NLS") != -1) { //$NON-NLS-1$
      return null;
    }
    // local variables
    int currentToken = 0;
    int splitTokenType = 0;
    int splitTokenDepth = Integer.MAX_VALUE;
    int splitTokenPriority = Integer.MAX_VALUE;

    int[] substringsStartPositions = new int[10];
    // contains the start position of substrings
    int[] substringsEndPositions = new int[10];
    // contains the start position of substrings
    int substringsCount = 1; // index in the substringsStartPosition array
    int[] splitOperators = new int[10];
    // contains the start position of substrings
    int splitOperatorsCount = 0; // index in the substringsStartPosition array
    int[] openParenthesisPosition = new int[10];
    int openParenthesisPositionCount = 0;
    int position = 0;
    int lastOpenParenthesisPosition = -1;
    // used to remember the position of the 1st open parenthesis
    // needed for a pattern like: A.B(C); we want formatted like A.B( split C);
    // setup the scanner with a new source
    int lastCommentStartPosition = -1;
    // to remember the start position of the last comment
    int firstTokenOnLine = -1;
    // to remember the first token of the line
    int previousToken = -1;
    // to remember the previous token.
    splitScanner.setSource(stringToSplit.toCharArray());

    try {
      // start the loop
      while (true) {
        // takes the next token
        try {
          if (currentToken != Scanner.TokenNameWHITESPACE)
            previousToken = currentToken;
          currentToken = splitScanner.getNextToken();
          if (Scanner.DEBUG) {
            int currentEndPosition = splitScanner.getCurrentTokenEndPosition();
            int currentStartPosition = splitScanner.getCurrentTokenStartPosition();

            System.out.print(currentStartPosition + "," + currentEndPosition + ": ");
            System.out.println(scanner.toStringAction(currentToken));
          }
        } catch (InvalidInputException e) {
          if (!handleInvalidToken(e))
            throw e;
          currentToken = 0;
          // this value is not modify when an exception is raised.
        }
        if (currentToken == TokenNameEOF)
          break;

        if (firstTokenOnLine == -1) {
          firstTokenOnLine = currentToken;
        }
        switch (currentToken) {
          case TokenNameRBRACE :
          case TokenNameRPAREN :
            if (openParenthesisPositionCount > 0) {
              if (openParenthesisPositionCount == 1 && lastOpenParenthesisPosition < openParenthesisPosition[0]) {
                lastOpenParenthesisPosition = openParenthesisPosition[0];
              } else if (
                (splitTokenDepth == Integer.MAX_VALUE)
                  || (splitTokenDepth > openParenthesisPositionCount && openParenthesisPositionCount == 1)) {
                splitTokenType = 0;
                splitTokenDepth = openParenthesisPositionCount;
                splitTokenPriority = Integer.MAX_VALUE;
                substringsStartPositions[0] = 0;
                // better token means the whole line until now is the first substring
                substringsCount = 1; // resets the count of substrings
                substringsEndPositions[0] = openParenthesisPosition[0];
                // substring ends on operator start
                position = openParenthesisPosition[0];
                // the string mustn't be cut before the closing parenthesis but after the opening one.
                splitOperatorsCount = 1; // resets the count of split operators
                splitOperators[0] = 0;
              }
              openParenthesisPositionCount--;
            }
            break;
          case TokenNameLBRACE :
          case TokenNameLPAREN :
            if (openParenthesisPositionCount == openParenthesisPosition.length) {
              System.arraycopy(
                openParenthesisPosition,
                0,
                (openParenthesisPosition = new int[openParenthesisPositionCount * 2]),
                0,
                openParenthesisPositionCount);
            }
            openParenthesisPosition[openParenthesisPositionCount++] = splitScanner.currentPosition;
            if (currentToken == TokenNameLPAREN && previousToken == TokenNameRPAREN) {
              openParenthesisPosition[openParenthesisPositionCount - 1] = splitScanner.startPosition;
            }
            break;
          case TokenNameSEMICOLON : // ;
          case TokenNameCOMMA : // ,
          case TokenNameEQUAL : // =
            if (openParenthesisPositionCount < splitTokenDepth
              || (openParenthesisPositionCount == splitTokenDepth && splitTokenPriority > getTokenPriority(currentToken))) {
              // the current token is better than the one we currently have
              // (in level or in priority if same level)
              // reset the substringsCount
              splitTokenDepth = openParenthesisPositionCount;
              splitTokenType = currentToken;
              splitTokenPriority = getTokenPriority(currentToken);
              substringsStartPositions[0] = 0;
              // better token means the whole line until now is the first substring

              if (separateFirstArgumentOn(firstTokenOnLine) && openParenthesisPositionCount > 0) {
                substringsCount = 2; // resets the count of substrings

                substringsEndPositions[0] = openParenthesisPosition[splitTokenDepth - 1];
                substringsStartPositions[1] = openParenthesisPosition[splitTokenDepth - 1];
                substringsEndPositions[1] = splitScanner.startPosition;
                splitOperatorsCount = 2; // resets the count of split operators
                splitOperators[0] = 0;
                splitOperators[1] = currentToken;
                position = splitScanner.currentPosition;
                // next substring will start from operator end
              } else {
                substringsCount = 1; // resets the count of substrings

                substringsEndPositions[0] = splitScanner.startPosition;
                // substring ends on operator start
                position = splitScanner.currentPosition;
                // next substring will start from operator end
                splitOperatorsCount = 1; // resets the count of split operators
                splitOperators[0] = currentToken;
              }
            } else {
              if ((openParenthesisPositionCount == splitTokenDepth && splitTokenPriority == getTokenPriority(currentToken))
                && splitTokenType != TokenNameEQUAL
                && currentToken != TokenNameEQUAL) {
                // fix for 1FG0BCN: LFCOM:WIN98 - Missing one indentation after split
                // take only the 1st = into account.
                // if another token with the same priority is found,
                // push the start position of the substring and
                // push the token into the stack.
                // create a new array object if the current one is full.
                if (substringsCount == substringsStartPositions.length) {
                  System.arraycopy(
                    substringsStartPositions,
                    0,
                    (substringsStartPositions = new int[substringsCount * 2]),
                    0,
                    substringsCount);
                  System.arraycopy(
                    substringsEndPositions,
                    0,
                    (substringsEndPositions = new int[substringsCount * 2]),
                    0,
                    substringsCount);
                }
                if (splitOperatorsCount == splitOperators.length) {
                  System.arraycopy(splitOperators, 0, (splitOperators = new int[splitOperatorsCount * 2]), 0, splitOperatorsCount);
                }
                substringsStartPositions[substringsCount] = position;
                substringsEndPositions[substringsCount++] = splitScanner.startPosition;
                // substring ends on operator start
                position = splitScanner.currentPosition;
                // next substring will start from operator end
                splitOperators[splitOperatorsCount++] = currentToken;
              }
            }
            break;

          case TokenNameCOLON : // : (15.24)
            // see 1FK7C5R, we only split on a colon, when it is associated with a question-mark.
            // indeed it might appear also behind a case statement, and we do not to break at this point.
            if ((splitOperatorsCount == 0) || splitOperators[splitOperatorsCount - 1] != TokenNameQUESTION) {
              break;
            }
          case TokenNameextends :
            //			case TokenNameimplements :
            //			case TokenNamethrows :

          case TokenNameDOT : // .
          case TokenNameMULTIPLY : // * (15.16.1)
          case TokenNameDIVIDE : // / (15.16.2)
          case TokenNameREMAINDER : // % (15.16.3)
          case TokenNamePLUS : // + (15.17, 15.17.2)
          case TokenNameMINUS : // - (15.17.2)
          case TokenNameLEFT_SHIFT : // << (15.18)
          case TokenNameRIGHT_SHIFT : // >> (15.18)
            //				case TokenNameUNSIGNED_RIGHT_SHIFT : // >>> (15.18)
          case TokenNameLESS : // < (15.19.1)
          case TokenNameLESS_EQUAL : // <= (15.19.1)
          case TokenNameGREATER : // > (15.19.1)
          case TokenNameGREATER_EQUAL : // >= (15.19.1)
            //				case TokenNameinstanceof : // instanceof
          case TokenNameEQUAL_EQUAL : // == (15.20, 15.20.1, 15.20.2, 15.20.3)
          case TokenNameEQUAL_EQUAL_EQUAL : // == (15.20, 15.20.1, 15.20.2, 15.20.3)
          case TokenNameNOT_EQUAL : // != (15.20, 15.20.1, 15.20.2, 15.20.3)
					case TokenNameNOT_EQUAL_EQUAL : // != (15.20, 15.20.1, 15.20.2, 15.20.3)
          case TokenNameAND : // & (15.21, 15.21.1, 15.21.2)
          case TokenNameOR : // | (15.21, 15.21.1, 15.21.2)
          case TokenNameXOR : // ^ (15.21, 15.21.1, 15.21.2)
          case TokenNameAND_AND : // && (15.22)
          case TokenNameOR_OR : // || (15.23)
          case TokenNameQUESTION : // ? (15.24)
          case TokenNameMULTIPLY_EQUAL : // *= (15.25.2)
          case TokenNameDIVIDE_EQUAL : // /= (15.25.2)
          case TokenNameREMAINDER_EQUAL : // %= (15.25.2)
          case TokenNamePLUS_EQUAL : // += (15.25.2)
          case TokenNameMINUS_EQUAL : // -= (15.25.2)
          case TokenNameLEFT_SHIFT_EQUAL : // <<= (15.25.2)
          case TokenNameRIGHT_SHIFT_EQUAL : // >>= (15.25.2)
            //					case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>= (15.25.2)
          case TokenNameAND_EQUAL : // &= (15.25.2)
          case TokenNameXOR_EQUAL : // ^= (15.25.2)
          case TokenNameOR_EQUAL : // |= (15.25.2)

            if ((openParenthesisPositionCount < splitTokenDepth
              || (openParenthesisPositionCount == splitTokenDepth && splitTokenPriority > getTokenPriority(currentToken)))
              && !((currentToken == TokenNamePLUS || currentToken == TokenNameMINUS)
                && (previousToken == TokenNameLBRACE || previousToken == TokenNameLBRACKET || splitScanner.startPosition == 0))) {
              // the current token is better than the one we currently have
              // (in level or in priority if same level)
              // reset the substringsCount
              splitTokenDepth = openParenthesisPositionCount;
              splitTokenType = currentToken;
              splitTokenPriority = getTokenPriority(currentToken);
              substringsStartPositions[0] = 0;
              // better token means the whole line until now is the first substring

              if (separateFirstArgumentOn(firstTokenOnLine) && openParenthesisPositionCount > 0) {
                substringsCount = 2; // resets the count of substrings

                substringsEndPositions[0] = openParenthesisPosition[splitTokenDepth - 1];
                substringsStartPositions[1] = openParenthesisPosition[splitTokenDepth - 1];
                substringsEndPositions[1] = splitScanner.startPosition;
                splitOperatorsCount = 3; // resets the count of split operators
                splitOperators[0] = 0;
                splitOperators[1] = 0;
                splitOperators[2] = currentToken;
                position = splitScanner.currentPosition;
                // next substring will start from operator end
              } else {
                substringsCount = 1; // resets the count of substrings

                substringsEndPositions[0] = splitScanner.startPosition;
                // substring ends on operator start
                position = splitScanner.currentPosition;
                // next substring will start from operator end
                splitOperatorsCount = 2; // resets the count of split operators
                splitOperators[0] = 0;
                // nothing for first operand since operator will be inserted in front of the second operand
                splitOperators[1] = currentToken;

              }
            } else {
              if (openParenthesisPositionCount == splitTokenDepth && splitTokenPriority == getTokenPriority(currentToken)) {
                // if another token with the same priority is found,
                // push the start position of the substring and
                // push the token into the stack.
                // create a new array object if the current one is full.
                if (substringsCount == substringsStartPositions.length) {
                  System.arraycopy(
                    substringsStartPositions,
                    0,
                    (substringsStartPositions = new int[substringsCount * 2]),
                    0,
                    substringsCount);
                  System.arraycopy(
                    substringsEndPositions,
                    0,
                    (substringsEndPositions = new int[substringsCount * 2]),
                    0,
                    substringsCount);
                }
                if (splitOperatorsCount == splitOperators.length) {
                  System.arraycopy(splitOperators, 0, (splitOperators = new int[splitOperatorsCount * 2]), 0, splitOperatorsCount);
                }
                substringsStartPositions[substringsCount] = position;
                substringsEndPositions[substringsCount++] = splitScanner.startPosition;
                // substring ends on operator start
                position = splitScanner.currentPosition;
                // next substring will start from operator end
                splitOperators[splitOperatorsCount++] = currentToken;
              }
            }
          default :
            break;
        }
        if (isComment(currentToken)) {
          lastCommentStartPosition = splitScanner.startPosition;
        } else {
          lastCommentStartPosition = -1;
        }
      }
    } catch (InvalidInputException e) {
      return null;
    }
    // if the string cannot be split, return null.
    if (splitOperatorsCount == 0)
      return null;

    // ## SPECIAL CASES BEGIN
    if (((splitOperatorsCount == 2
      && splitOperators[1] == TokenNameDOT
      && splitTokenDepth == 0
      && lastOpenParenthesisPosition > -1)
      || (splitOperatorsCount > 2
        && splitOperators[1] == TokenNameDOT
        && splitTokenDepth == 0
        && lastOpenParenthesisPosition > -1
        && lastOpenParenthesisPosition <= options.maxLineLength)
      || (separateFirstArgumentOn(firstTokenOnLine) && splitTokenDepth > 0 && lastOpenParenthesisPosition > -1))
      && (lastOpenParenthesisPosition < splitScanner.source.length && splitScanner.source[lastOpenParenthesisPosition] != ')')) {
      // fix for 1FH4J2H: LFCOM:WINNT - Formatter - Empty parenthesis should not be broken on two lines
      // only one split on a top level .
      // or more than one split on . and substring before open parenthesis fits one line.
      // or split inside parenthesis and first token is not a for/while/if
      SplitLine sl = split(stringToSplit.substring(lastOpenParenthesisPosition), lastOpenParenthesisPosition);
      if (sl == null || sl.operators[0] != TokenNameCOMMA) {
        // trim() is used to remove the extra blanks at the end of the substring. See PR 1FGYPI1
        return new SplitLine(
          new int[] { 0, 0 },
          new String[] {
            stringToSplit.substring(0, lastOpenParenthesisPosition).trim(),
            stringToSplit.substring(lastOpenParenthesisPosition)},
          new int[] { offsetInGlobalLine, lastOpenParenthesisPosition + offsetInGlobalLine });
      } else {
        // right substring can be split and is split on comma
        // copy substrings and operators
        // except if the 1st string is empty.
        int startIndex = (sl.substrings[0].length() == 0) ? 1 : 0;
        int subStringsLength = sl.substrings.length + 1 - startIndex;
        String[] result = new String[subStringsLength];
        int[] startIndexes = new int[subStringsLength];
        int operatorsLength = sl.operators.length + 1 - startIndex;
        int[] operators = new int[operatorsLength];

        result[0] = stringToSplit.substring(0, lastOpenParenthesisPosition);
        operators[0] = 0;

        System.arraycopy(sl.startSubstringsIndexes, startIndex, startIndexes, 1, subStringsLength - 1);
        for (int i = subStringsLength - 1; i >= 0; i--) {
          startIndexes[i] += offsetInGlobalLine;
        }
        System.arraycopy(sl.substrings, startIndex, result, 1, subStringsLength - 1);
        System.arraycopy(sl.operators, startIndex, operators, 1, operatorsLength - 1);

        return new SplitLine(operators, result, startIndexes);
      }
    }
    // if the last token is a comment and the substring before the comment fits on a line,
    // split before the comment and return the result.
    if (lastCommentStartPosition > -1 && lastCommentStartPosition < options.maxLineLength && splitTokenPriority > 50) {
      int end = lastCommentStartPosition;
      int start = lastCommentStartPosition;
      if (stringToSplit.charAt(end - 1) == ' ') {
        end--;
      }
      if (start != end && stringToSplit.charAt(start) == ' ') {
        start++;
      }
      return new SplitLine(
        new int[] { 0, 0 },
        new String[] { stringToSplit.substring(0, end), stringToSplit.substring(start)},
        new int[] { 0, start });
    }
    if (position != stringToSplit.length()) {
      if (substringsCount == substringsStartPositions.length) {
        System.arraycopy(
          substringsStartPositions,
          0,
          (substringsStartPositions = new int[substringsCount * 2]),
          0,
          substringsCount);
        System.arraycopy(substringsEndPositions, 0, (substringsEndPositions = new int[substringsCount * 2]), 0, substringsCount);
      }
      // avoid empty extra substring, e.g. line terminated with a semi-colon
      substringsStartPositions[substringsCount] = position;
      substringsEndPositions[substringsCount++] = stringToSplit.length();
    }
    if (splitOperatorsCount == splitOperators.length) {
      System.arraycopy(splitOperators, 0, (splitOperators = new int[splitOperatorsCount * 2]), 0, splitOperatorsCount);
    }
    splitOperators[splitOperatorsCount] = 0;

    // the last element of the stack is the position of the end of StringToSPlit
    // +1 because the substring method excludes the last character
    String[] result = new String[substringsCount];
    for (int i = 0; i < substringsCount; i++) {
      int start = substringsStartPositions[i];
      int end = substringsEndPositions[i];
      if (stringToSplit.charAt(start) == ' ') {
        start++;
        substringsStartPositions[i]++;
      }
      if (end != start && stringToSplit.charAt(end - 1) == ' ') {
        end--;
      }
      result[i] = stringToSplit.substring(start, end);
      substringsStartPositions[i] += offsetInGlobalLine;
    }
    if (splitOperatorsCount > substringsCount) {
      System.arraycopy(substringsStartPositions, 0, (substringsStartPositions = new int[splitOperatorsCount]), 0, substringsCount);
      System.arraycopy(substringsEndPositions, 0, (substringsEndPositions = new int[splitOperatorsCount]), 0, substringsCount);
      for (int i = substringsCount; i < splitOperatorsCount; i++) {
        substringsStartPositions[i] = position;
        substringsEndPositions[i] = position;
      }
      System.arraycopy(splitOperators, 0, (splitOperators = new int[splitOperatorsCount]), 0, splitOperatorsCount);
    } else {
      System.arraycopy(substringsStartPositions, 0, (substringsStartPositions = new int[substringsCount]), 0, substringsCount);
      System.arraycopy(substringsEndPositions, 0, (substringsEndPositions = new int[substringsCount]), 0, substringsCount);
      System.arraycopy(splitOperators, 0, (splitOperators = new int[substringsCount]), 0, substringsCount);
    }
    SplitLine splitLine = new SplitLine(splitOperators, result, substringsStartPositions);
    return splitLine;
  }

  private void updateMappedPositions(int startPosition) {
    if (positionsToMap == null) {
      return;
    }
    char[] source = scanner.source;
    int sourceLength = source.length;
    while (indexToMap < positionsToMap.length && positionsToMap[indexToMap] <= startPosition) {
      int posToMap = positionsToMap[indexToMap];
      if (posToMap < 0 || posToMap >= sourceLength) {
        // protection against out of bounds position
        if (posToMap == sourceLength) {
          mappedPositions[indexToMap] = formattedSource.length();
        }
        indexToMap = positionsToMap.length; // no more mapping
        return;
      }
      if (CharOperation.isWhitespace(source[posToMap])) {
        mappedPositions[indexToMap] = startPosition + globalDelta + lineDelta;
      } else {
        if (posToMap == sourceLength - 1) {
          mappedPositions[indexToMap] = startPosition + globalDelta + lineDelta;
        } else {
          mappedPositions[indexToMap] = posToMap + globalDelta + lineDelta;
        }
      }
      indexToMap++;
    }
  }

  private void updateMappedPositionsWhileSplitting(int startPosition, int endPosition) {
    if (mappedPositions == null || mappedPositions.length == indexInMap)
      return;

    while (indexInMap < mappedPositions.length
      && startPosition <= mappedPositions[indexInMap]
      && mappedPositions[indexInMap] < endPosition
      && indexInMap < indexToMap) {
      mappedPositions[indexInMap] += splitDelta;
      indexInMap++;
    }
  }

  private int getLength(String s, int tabDepth) {
    int length = 0;
    for (int i = 0; i < tabDepth; i++) {
      length += options.tabSize;
    }
    for (int i = 0, max = s.length(); i < max; i++) {
      char currentChar = s.charAt(i);
      switch (currentChar) {
        case '\t' :
          length += options.tabSize;
          break;
        default :
          length++;
      }
    }
    return length;
  }

  /** 
  * Sets the initial indentation level
  * @param indentationLevel new indentation level
  * 
  * @deprecated
  */
  public void setInitialIndentationLevel(int newIndentationLevel) {
    this.initialIndentationLevel = currentLineIndentationLevel = indentationLevel = newIndentationLevel;
  }
}