d209db011cb2e7f05fe80c2e65fac27802243077
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / formatter / CodeFormatter.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Common Public License v0.5
5  *
6  * which accompanies this distribution, and is available at
7  * http://www.eclipse.org/legal/cpl-v05.html
8  *
9  * Contributors:
10  *     IBM Corporation - initial API and implementation
11  ******************************************************************************/
12 package net.sourceforge.phpdt.internal.formatter;
13
14 import java.io.BufferedReader;
15 import java.io.IOException;
16 import java.io.StringReader;
17 import java.util.Hashtable;
18 import java.util.Locale;
19 import java.util.Map;
20
21 //import javax.swing.text.html.Option;
22
23 import net.sourceforge.phpdt.core.ICodeFormatter;
24 import net.sourceforge.phpdt.core.compiler.CharOperation;
25 import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
26 import net.sourceforge.phpdt.core.compiler.InvalidInputException;
27 import net.sourceforge.phpdt.internal.compiler.ConfigurableOption;
28 import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
29 import net.sourceforge.phpdt.internal.formatter.impl.FormatterOptions;
30 import net.sourceforge.phpdt.internal.formatter.impl.SplitLine;
31
32 /**
33  * <h2>How to format a piece of code ?</h2>
34  * <ul>
35  * <li>Create an instance of <code>CodeFormatter</code>
36  * <li>Use the method <code>void format(aString)</code> on this instance to
37  * format <code>aString</code>. It will return the formatted string.
38  * </ul>
39  */
40 public class CodeFormatter implements ITerminalSymbols, ICodeFormatter {
41         // IContentFormatterExtension {
42         public FormatterOptions options;
43
44         /**
45          * Represents a block in the <code>constructions</code> stack.
46          */
47         public static final int BLOCK = ITerminalSymbols.TokenNameLBRACE;
48
49         /**
50          * Represents a block following a control statement in the
51          * <code>constructions</code> stack.
52          */
53         public static final int NONINDENT_BLOCK = -100;
54
55         /**
56          * Contains the formatted output.
57          */
58         StringBuffer formattedSource;
59
60         /**
61          * Contains the current line. <br>
62          * Will be dumped at the next "newline"
63          */
64         StringBuffer currentLineBuffer;
65
66         /**
67          * Used during the formatting to get each token.
68          */
69         Scanner scanner;
70
71         /**
72          * Contains the tokens responsible for the current indentation level and the
73          * blocks not closed yet.
74          */
75         private int[] constructions;
76
77         /**
78          * Index in the <code>constructions</code> array.
79          */
80         private int constructionsCount;
81
82         /**
83          * Level of indentation of the current token (number of tab char put in
84          * front of it).
85          */
86         private int indentationLevel;
87
88         /**
89          * Regular level of indentation of all the lines
90          */
91         private int initialIndentationLevel;
92
93         /**
94          * Used to split a line.
95          */
96         Scanner splitScanner;
97
98         /**
99          * To remember the offset between the beginning of the line and the
100          * beginning of the comment.
101          */
102         int currentCommentOffset;
103
104         int currentLineIndentationLevel;
105
106         int maxLineSize = 30;
107
108         private boolean containsOpenCloseBraces;
109
110         private int indentationLevelForOpenCloseBraces;
111
112         /**
113          * Collections of positions to map
114          */
115         private int[] positionsToMap;
116
117         /**
118          * Collections of mapped positions
119          */
120         private int[] mappedPositions;
121
122         private int indexToMap;
123
124         private int indexInMap;
125
126         private int globalDelta;
127
128         private int lineDelta;
129
130         private int splitDelta;
131
132         private int beginningOfLineIndex;
133
134         private int multipleLineCommentCounter;
135
136         /**
137          * Creates a new instance of Code Formatter using the given settings.
138          * 
139          * @deprecated backport 1.0 internal functionality
140          */
141         public CodeFormatter(ConfigurableOption[] settings) {
142                 this(convertConfigurableOptions(settings));
143         }
144
145         /**
146          * Creates a new instance of Code Formatter using the FormattingOptions
147          * object given as argument
148          * 
149          * @deprecated Use CodeFormatter(ConfigurableOption[]) instead
150          */
151         public CodeFormatter() {
152                 this((Map) null);
153         }
154
155         /**
156          * Creates a new instance of Code Formatter using the given settings.
157          */
158         public CodeFormatter(Map settings) {
159                 // initialize internal state
160                 constructionsCount = 0;
161                 constructions = new int[10];
162                 currentLineIndentationLevel = indentationLevel = initialIndentationLevel;
163                 currentCommentOffset = -1;
164                 // initialize primary and secondary scanners
165                 scanner = new Scanner(true /* comment */
166                 , true /* whitespace */
167                 , false /* nls */
168                 , false /* assert */
169                 , true, /* tokenizeStrings */
170                 null, null, true /* taskCaseSensitive */); // regular scanner for
171                                                                                                         // forming lines
172                 scanner.recordLineSeparator = true;
173                 scanner.ignorePHPOneLiner = true;
174                 // to remind of the position of the beginning of the line.
175                 splitScanner = new Scanner(true /* comment */
176                 , true /* whitespace */
177                 , false /* nls */
178                 , false /* assert */
179                 , true, /* tokenizeStrings */
180                 null, null, true /* taskCaseSensitive */);
181                 splitScanner.ignorePHPOneLiner = true;
182                 // secondary scanner to split long lines formed by primary scanning
183                 // initialize current line buffer
184                 currentLineBuffer = new StringBuffer();
185                 this.options = new FormatterOptions(settings);
186         }
187
188         /**
189          * Returns true if a lineSeparator has to be inserted before
190          * <code>operator</code> false otherwise.
191          */
192         private static boolean breakLineBeforeOperator(int operator) {
193                 switch (operator) {
194                 case TokenNameCOMMA:
195                 case TokenNameSEMICOLON:
196                 case TokenNameEQUAL:
197                         return false;
198                 default:
199                         return true;
200                 }
201         }
202
203         /**
204          * @deprecated backport 1.0 internal functionality
205          */
206         private static Map convertConfigurableOptions(ConfigurableOption[] settings) {
207                 Hashtable options = new Hashtable(10);
208                 for (int i = 0; i < settings.length; i++) {
209                         if (settings[i].getComponentName().equals(
210                                         CodeFormatter.class.getName())) {
211                                 String optionName = settings[i].getOptionName();
212                                 int valueIndex = settings[i].getCurrentValueIndex();
213                                 if (optionName.equals("newline.openingBrace")) { //$NON-NLS-1$
214                                         options
215                                                         .put(
216                                                                         "net.sourceforge.phpdt.core.formatter.newline.openingBrace", valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
217                                 } else if (optionName.equals("newline.controlStatement")) { //$NON-NLS-1$
218                                         options
219                                                         .put(
220                                                                         "net.sourceforge.phpdt.core.formatter.newline.controlStatement", valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
221                                 } else if (optionName.equals("newline.clearAll")) { //$NON-NLS-1$
222                                         options
223                                                         .put(
224                                                                         "net.sourceforge.phpdt.core.formatter.newline.clearAll", valueIndex == 0 ? "clear all" : "preserve one"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
225                                 } else if (optionName.equals("newline.elseIf")) { //$NON-NLS-1$
226                                         options
227                                                         .put(
228                                                                         "net.sourceforge.phpdt.core.formatter.newline.elseIf", valueIndex == 0 ? "do not insert" : "insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
229                                 } else if (optionName.equals("newline.emptyBlock")) { //$NON-NLS-1$
230                                         options
231                                                         .put(
232                                                                         "net.sourceforge.phpdt.core.formatter.newline.emptyBlock", valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
233                                 } else if (optionName.equals("lineSplit")) { //$NON-NLS-1$
234                                         options
235                                                         .put(
236                                                                         "net.sourceforge.phpdt.core.formatter.lineSplit", String.valueOf(valueIndex)); //$NON-NLS-1$ //$NON-NLS-2$
237                                 } else if (optionName.equals("style.assignment")) { //$NON-NLS-1$
238                                         options
239                                                         .put(
240                                                                         "net.sourceforge.phpdt.core.formatter.style.assignment", valueIndex == 0 ? "compact" : "normal"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
241                                 } else if (optionName.equals("tabulation.char")) { //$NON-NLS-1$
242                                         options
243                                                         .put(
244                                                                         "net.sourceforge.phpdt.core.formatter.tabulation.char", valueIndex == 0 ? "tab" : "space"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
245                                 } else if (optionName.equals("tabulation.size")) { //$NON-NLS-1$
246                                         options
247                                                         .put(
248                                                                         "net.sourceforge.phpdt.core.formatter.tabulation.size", String.valueOf(valueIndex)); //$NON-NLS-1$ //$NON-NLS-2$
249                                 }
250                         }
251                 }
252                 return options;
253         }
254
255         /**
256          * Returns the end of the source code.
257          */
258         private final String copyRemainingSource() {
259                 char str[] = scanner.source;
260                 int startPosition = scanner.startPosition;
261                 int length = str.length - startPosition;
262                 StringBuffer bufr = new StringBuffer(length);
263                 if (startPosition < str.length) {
264                         bufr.append(str, startPosition, length);
265                 }
266                 return (bufr.toString());
267         }
268
269         /**
270          * Inserts <code>tabCount</code> tab character or their equivalent number
271          * of spaces.
272          */
273         private void dumpTab(int tabCount) {
274                 if (options.indentWithTab) {
275                         for (int j = 0; j < tabCount; j++) {
276                                 formattedSource.append('\t');
277                                 increaseSplitDelta(1);
278                         }
279                 } else {
280                         for (int i = 0, max = options.tabSize * tabCount; i < max; i++) {
281                                 formattedSource.append(' ');
282                                 increaseSplitDelta(1);
283                         }
284                 }
285         }
286
287         /**
288          * Dumps <code>currentLineBuffer</code> into the formatted string.
289          */
290         private void flushBuffer() {
291                 String currentString = currentLineBuffer.toString();
292                 splitDelta = 0;
293                 beginningOfLineIndex = formattedSource.length();
294                 if (containsOpenCloseBraces) {
295                         containsOpenCloseBraces = false;
296                         outputLine(currentString, false,
297                                         indentationLevelForOpenCloseBraces, 0, -1, null, 0);
298                         indentationLevelForOpenCloseBraces = currentLineIndentationLevel;
299                 } else {
300                         outputLine(currentString, false, currentLineIndentationLevel, 0,
301                                         -1, null, 0);
302                 }
303                 int scannerSourceLength = scanner.source.length;
304                 if ((scannerSourceLength > 2)
305                                 && (scanner.startPosition < scannerSourceLength)) {
306                         if (scanner.source[scannerSourceLength - 1] == '\n'
307                                         && scanner.source[scannerSourceLength - 2] == '\r') {
308                                 formattedSource.append(options.lineSeparatorSequence);
309                                 increaseGlobalDelta(options.lineSeparatorSequence.length - 2);
310                         } else if (scanner.source[scannerSourceLength - 1] == '\n') {
311                                 formattedSource.append(options.lineSeparatorSequence);
312                                 increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
313                         } else if (scanner.source[scannerSourceLength - 1] == '\r') {
314                                 formattedSource.append(options.lineSeparatorSequence);
315                                 increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
316                         }
317                 }
318                 updateMappedPositions(scanner.startPosition);
319         }
320
321         /**
322          * Formats the input string.
323          */
324         private void format() {
325                 int token = 0;
326                 int previousToken = 0;
327                 int previousCompilableToken = 0;
328                 int indentationOffset = 0;
329                 int newLinesInWhitespace = 0;
330                 // number of new lines in the previous whitespace token
331                 // (used to leave blank lines before comments)
332                 int pendingNewLines = 0;
333                 boolean expectingOpenBrace = false;
334                 boolean clearNonBlockIndents = false;
335                 // true if all indentations till the 1st { (usefull after } or ;)
336                 boolean pendingSpace = true;
337                 boolean pendingNewlineAfterParen = false;
338                 // true when a cr is to be put after a ) (in conditional statements)
339                 boolean inAssignment = false;
340                 boolean inArrayAssignment = false;
341                 boolean inThrowsClause = false;
342                 boolean inClassOrInterfaceHeader = false;
343                 int dollarBraceCount = 0;
344                 // openBracketCount is used to count the number of open brackets not
345                 // closed
346                 // yet.
347                 int openBracketCount = 0;
348                 int unarySignModifier = 0;
349                 // openParenthesis[0] is used to count the parenthesis not belonging to
350                 // a
351                 // condition
352                 // (eg foo();). parenthesis in for (...) are count elsewhere in the
353                 // array.
354                 int openParenthesisCount = 1;
355                 int[] openParenthesis = new int[10];
356                 // tokenBeforeColon is used to know what token goes along with the
357                 // current
358                 // :
359                 // it can be case or ?
360                 int tokenBeforeColonCount = 0;
361                 int[] tokenBeforeColon = new int[10];
362                 constructionsCount = 0; // initializes the constructions count.
363                 // contains DO if in a DO..WHILE statement, UNITIALIZED otherwise.
364                 int nlicsToken = 0;
365                 // fix for 1FF17XY: LFCOM:ALL - Format problem on not matching } and
366                 // else
367                 boolean specialElse = false;
368                 // OPTION (IndentationLevel): initial indentation level may be non-zero.
369                 currentLineIndentationLevel += constructionsCount;
370                 // An InvalidInputException exception might cause the termination of
371                 // this
372                 // loop.
373                 int arrayDeclarationCount = 0;
374                 int[] arrayDeclarationParenthesis = new int[10];
375                 try {
376                         while (true) {
377                                 // Get the next token. Catch invalid input and output it
378                                 // with minimal formatting, also catch end of input and
379                                 // exit the loop.
380                                 try {
381                                         token = scanner.getNextToken();
382                                         if (Scanner.DEBUG) {
383                                                 int currentEndPosition = scanner
384                                                                 .getCurrentTokenEndPosition();
385                                                 int currentStartPosition = scanner
386                                                                 .getCurrentTokenStartPosition();
387                                                 System.out.print(currentStartPosition + ","
388                                                                 + currentEndPosition + ": ");
389                                                 System.out.println(scanner.toStringAction(token));
390                                         }
391                                         // Patch for line comment
392                                         // See PR http://dev.eclipse.org/bugs/show_bug.cgi?id=23096
393                                         if (token == ITerminalSymbols.TokenNameCOMMENT_LINE) {
394                                                 int length = scanner.currentPosition;
395                                                 loop: for (int index = length - 1; index >= 0; index--) {
396                                                         switch (scanner.source[index]) {
397                                                         case '\r':
398                                                         case '\n':
399                                                                 scanner.currentPosition--;
400                                                                 break;
401                                                         default:
402                                                                 break loop;
403                                                         }
404                                                 }
405                                         }
406                                 } catch (InvalidInputException e) {
407                                         if (!handleInvalidToken(e)) {
408                                                 throw e;
409                                         }
410                                         token = 0;
411                                 }
412                                 if (token == Scanner.TokenNameEOF) {
413                                         break;
414                                 } else if (token == Scanner.TokenNameHEREDOC) {
415                                         // no indentation for heredocs and HTML !
416                                         outputCurrentTokenWithoutIndent(Scanner.TokenNameHEREDOC, 0);
417                                         continue;
418                                 } else if (token == Scanner.TokenNameINLINE_HTML) {
419                                         // no indentation for heredocs and HTML !
420                                         int newLineCount = 1;
421                                         if (scanner.startPosition == 0) {
422                                                 newLineCount = 0;
423                                         }
424                                         outputCurrentTokenWithoutIndent(
425                                                         Scanner.TokenNameINLINE_HTML, newLineCount);
426                                         int srcLen = scanner.source.length;
427                                         if (scanner.currentPosition < srcLen - 1) {
428                                                 newLine(1);
429                                         }
430                                         continue;
431                                 }
432                                 /*
433                                  * ## MODIFYING the indentation level before generating new
434                                  * lines and indentation in the output string
435                                  */
436                                 // Removes all the indentations made by statements not followed
437                                 // by a
438                                 // block
439                                 // except if the current token is ELSE, CATCH or if we are in a
440                                 // switch/case
441                                 if (clearNonBlockIndents
442                                                 && (token != Scanner.TokenNameWHITESPACE)) {
443                                         switch (token) {
444                                         case TokenNameelse:
445                                                 if (constructionsCount > 0
446                                                                 && constructions[constructionsCount - 1] == TokenNameelse) {
447                                                         pendingNewLines = 1;
448                                                         specialElse = true;
449                                                 }
450                                                 indentationLevel += popInclusiveUntil(TokenNameif);
451                                                 break;
452                                         // case TokenNamecatch :
453                                         // indentationLevel += popInclusiveUntil(TokenNamecatch);
454                                         // break;
455                                         // case TokenNamefinally :
456                                         // indentationLevel += popInclusiveUntil(TokenNamecatch);
457                                         // break;
458                                         case TokenNamewhile:
459                                                 if (nlicsToken == TokenNamedo) {
460                                                         indentationLevel += pop(TokenNamedo);
461                                                         break;
462                                                 }
463                                         default:
464                                                 indentationLevel += popExclusiveUntilBlockOrCase();
465                                                 // clear until a CASE, DEFAULT or BLOCK is encountered.
466                                                 // Thus, the indentationLevel is correctly cleared
467                                                 // either
468                                                 // in a switch/case statement or in any other situation.
469                                         }
470                                         clearNonBlockIndents = false;
471                                 }
472                                 // returns to the indentation level created by the SWITCH
473                                 // keyword
474                                 // if the current token is a CASE or a DEFAULT
475                                 if (token == TokenNamecase || token == TokenNamedefault) {
476                                         indentationLevel += pop(TokenNamecase);
477                                 }
478                                 // if (token == Scanner.TokenNamethrows) {
479                                 // inThrowsClause = true;
480                                 // }
481                                 if ((token == Scanner.TokenNameclass || token == Scanner.TokenNameinterface)
482                                                 && previousToken != Scanner.TokenNameDOT) {
483                                         inClassOrInterfaceHeader = true;
484                                 }
485                                 /*
486                                  * ## APPEND newlines and indentations to the output string
487                                  */
488                                 // Do not add a new line between ELSE and IF, if the option
489                                 // elseIfOnSameLine is true.
490                                 // Fix for 1ETLWPZ: IVJCOM:ALL - incorrect "else if" formatting
491                                 // if (pendingNewlineAfterParen
492                                 // && previousCompilableToken == TokenNameelse
493                                 // && token == TokenNameif
494                                 // && options.compactElseIfMode) {
495                                 // pendingNewlineAfterParen = false;
496                                 // pendingNewLines = 0;
497                                 // indentationLevel += pop(TokenNameelse);
498                                 // // because else if is now one single statement,
499                                 // // the indentation level after it is increased by one and not
500                                 // by 2
501                                 // // (else = 1 indent, if = 1 indent, but else if = 1 indent,
502                                 // not 2).
503                                 // }
504                                 // Add a newline & indent to the formatted source string if
505                                 // a for/if-else/while statement was scanned and there is no
506                                 // block
507                                 // following it.
508                                 pendingNewlineAfterParen = pendingNewlineAfterParen
509                                                 || (previousCompilableToken == TokenNameRPAREN && token == TokenNameLBRACE);
510                                 if (pendingNewlineAfterParen
511                                                 && token != Scanner.TokenNameWHITESPACE) {
512                                         pendingNewlineAfterParen = false;
513                                         // Do to add a newline & indent sequence if the current
514                                         // token is an
515                                         // open brace or a period or if the current token is a
516                                         // semi-colon and
517                                         // the
518                                         // previous token is a close paren.
519                                         // add a new line if a parenthesis belonging to a for()
520                                         // statement
521                                         // has been closed and the current token is not an opening
522                                         // brace
523                                         if (token != TokenNameLBRACE && !isComment(token)
524                                                         // to avoid adding new line between else and a
525                                                         // comment
526                                                         && token != TokenNameDOT
527                                                         && !(previousCompilableToken == TokenNameRPAREN && token == TokenNameSEMICOLON)) {
528                                                 newLine(1);
529                                                 currentLineIndentationLevel = indentationLevel;
530                                                 pendingNewLines = 0;
531                                                 pendingSpace = false;
532                                         } else {
533                                                 if (token == TokenNameLBRACE
534                                                                 && options.newLineBeforeOpeningBraceMode) {
535                                                         newLine(1);
536                                                         if (constructionsCount > 0
537                                                                         && constructions[constructionsCount - 1] != BLOCK
538                                                                         && constructions[constructionsCount - 1] != NONINDENT_BLOCK) {
539                                                                 currentLineIndentationLevel = indentationLevel - 1;
540                                                         } else {
541                                                                 currentLineIndentationLevel = indentationLevel;
542                                                         }
543                                                         pendingNewLines = 0;
544                                                         pendingSpace = false;
545                                                 }
546                                         }
547                                 }
548                                 if (token == TokenNameLBRACE
549                                                 && options.newLineBeforeOpeningBraceMode
550                                                 && constructionsCount > 0
551                                                 && constructions[constructionsCount - 1] == TokenNamedo) {
552                                         newLine(1);
553                                         currentLineIndentationLevel = indentationLevel - 1;
554                                         pendingNewLines = 0;
555                                         pendingSpace = false;
556                                 }
557                                 // see PR 1G5G8EC
558                                 if (token == TokenNameLBRACE && inThrowsClause) {
559                                         inThrowsClause = false;
560                                         if (options.newLineBeforeOpeningBraceMode) {
561                                                 newLine(1);
562                                                 currentLineIndentationLevel = indentationLevel;
563                                                 pendingNewLines = 0;
564                                                 pendingSpace = false;
565                                         }
566                                 }
567                                 // see PR 1G5G82G
568                                 if (token == TokenNameLBRACE && inClassOrInterfaceHeader) {
569                                         inClassOrInterfaceHeader = false;
570                                         if (options.newLineBeforeOpeningBraceMode) {
571                                                 newLine(1);
572                                                 currentLineIndentationLevel = indentationLevel;
573                                                 pendingNewLines = 0;
574                                                 pendingSpace = false;
575                                         }
576                                 }
577                                 // don't linebreak empty array declarations
578                                 if (token == TokenNameRPAREN && arrayDeclarationCount > 0) {
579                                         if (previousCompilableToken == TokenNameLPAREN) {
580                                                 pendingNewLines = 0;
581                                         }
582                                 }
583                                 // Add pending new lines to the formatted source string.
584                                 // Note: pending new lines are not added if the current token
585                                 // is a single line comment or whitespace.
586                                 // if the comment is between parenthesis, there is no blank line
587                                 // preservation
588                                 // (if it's a one-line comment, a blank line is added after it).
589                                 if (((pendingNewLines > 0 && (!isComment(token)))
590                                                 || (newLinesInWhitespace > 0 && (openParenthesisCount <= 1 && isComment(token)))
591                                                 || (previousCompilableToken == TokenNameLBRACE && token == TokenNameRBRACE) || (newLinesInWhitespace > 0 && previousCompilableToken == TokenNameDOT))
592                                                 && token != Scanner.TokenNameWHITESPACE) {
593                                         // Do not add newline & indent between an adjoining close
594                                         // brace and
595                                         // close paren. Anonymous inner classes may use this form.
596                                         boolean closeBraceAndCloseParen = previousToken == TokenNameRBRACE
597                                                         && token == TokenNameRPAREN;
598                                         // OPTION (NewLineInCompoundStatement): do not add newline &
599                                         // indent
600                                         // between close brace and else, (do) while, catch, and
601                                         // finally if
602                                         // newlineInCompoundStatement is true.
603                                         boolean nlicsOption = previousToken == TokenNameRBRACE
604                                                         && !options.newlineInControlStatementMode
605                                                         && (token == TokenNameelse
606                                                                         || (token == TokenNamewhile && nlicsToken == TokenNamedo)
607                                                                         || token == TokenNamecatch || token == TokenNamefinally);
608                                         // Do not add a newline & indent between a close brace and
609                                         // semi-colon.
610                                         boolean semiColonAndCloseBrace = previousToken == TokenNameRBRACE
611                                                         && token == TokenNameSEMICOLON;
612                                         // Do not add a new line & indent between a multiline
613                                         // comment and a
614                                         // opening brace
615                                         boolean commentAndOpenBrace = previousToken == Scanner.TokenNameCOMMENT_BLOCK
616                                                         && token == TokenNameLBRACE;
617                                         // Do not add a newline & indent between a close brace and a
618                                         // colon
619                                         // (in array assignments, for example).
620                                         boolean commaAndCloseBrace = previousToken == TokenNameRBRACE
621                                                         && token == TokenNameCOMMA;
622                                         // Add a newline and indent, if appropriate.
623                                         if (specialElse
624                                                         || (!commentAndOpenBrace
625                                                                         && !closeBraceAndCloseParen && !nlicsOption
626                                                                         && !semiColonAndCloseBrace && !commaAndCloseBrace)) {
627                                                 // if clearAllBlankLinesMode=false, leaves the blank
628                                                 // lines
629                                                 // inserted by the user
630                                                 // if clearAllBlankLinesMode=true, removes all of then
631                                                 // and insert only blank lines required by the
632                                                 // formatting.
633                                                 if (!options.clearAllBlankLinesMode) {
634                                                         // (isComment(token))
635                                                         pendingNewLines = (pendingNewLines < newLinesInWhitespace) ? newLinesInWhitespace
636                                                                         : pendingNewLines;
637                                                         pendingNewLines = (pendingNewLines > 2) ? 2
638                                                                         : pendingNewLines;
639                                                 }
640                                                 if (previousCompilableToken == TokenNameLBRACE
641                                                                 && token == TokenNameRBRACE) {
642                                                         containsOpenCloseBraces = true;
643                                                         indentationLevelForOpenCloseBraces = currentLineIndentationLevel;
644                                                         if (isComment(previousToken)) {
645                                                                 newLine(pendingNewLines);
646                                                         } else {
647                                                                 /*
648                                                                  * if (!(constructionsCount > 1 &&
649                                                                  * constructions[constructionsCount-1] ==
650                                                                  * NONINDENT_BLOCK &&
651                                                                  * (constructions[constructionsCount-2] ==
652                                                                  * TokenNamefor
653                                                                  */
654                                                                 if (options.newLineInEmptyBlockMode) {
655                                                                         if (inArrayAssignment) {
656                                                                                 newLine(1); // array assigment with an
657                                                                                                         // empty block
658                                                                         } else {
659                                                                                 newLine(pendingNewLines);
660                                                                         }
661                                                                 }
662                                                                 // }
663                                                         }
664                                                 } else {
665                                                         // see PR 1FKKC3U: LFCOM:WINNT - Format problem with
666                                                         // a comment
667                                                         // before the ';'
668                                                         if (!((previousToken == Scanner.TokenNameCOMMENT_BLOCK || previousToken == Scanner.TokenNameCOMMENT_PHPDOC) && token == TokenNameSEMICOLON)) {
669                                                                 newLine(pendingNewLines);
670                                                         }
671                                                 }
672                                                 if (((previousCompilableToken == TokenNameSEMICOLON)
673                                                                 || (previousCompilableToken == TokenNameLBRACE)
674                                                                 || (previousCompilableToken == TokenNameRBRACE) || (isComment(previousToken)))
675                                                                 && (token == TokenNameRBRACE)) {
676                                                         indentationOffset = -1;
677                                                         indentationLevel += popExclusiveUntilBlock();
678                                                 }
679                                                 if (previousToken == Scanner.TokenNameCOMMENT_LINE
680                                                                 && inAssignment) {
681                                                         // PR 1FI5IPO
682                                                         currentLineIndentationLevel++;
683                                                 } else {
684                                                         currentLineIndentationLevel = indentationLevel
685                                                                         + indentationOffset;
686                                                 }
687                                                 pendingSpace = false;
688                                                 indentationOffset = 0;
689                                         }
690                                         pendingNewLines = 0;
691                                         newLinesInWhitespace = 0;
692                                         specialElse = false;
693                                         if (nlicsToken == TokenNamedo && token == TokenNamewhile) {
694                                                 nlicsToken = 0;
695                                         }
696                                 }
697                                 boolean phpTagAndWhitespace = previousToken == TokenNameINLINE_HTML
698                                                 && token == TokenNameWHITESPACE;
699                                 switch (token) {
700                                 // case TokenNameDOLLAR :
701                                 // dollarBraceCount++;
702                                 // break;
703                                 case TokenNameelse:
704                                         // case TokenNamefinally :
705                                         expectingOpenBrace = true;
706                                         pendingNewlineAfterParen = true;
707                                         indentationLevel += pushControlStatement(token);
708                                         break;
709                                 case TokenNamecase:
710                                 case TokenNamedefault:
711                                         if (tokenBeforeColonCount == tokenBeforeColon.length) {
712                                                 System
713                                                                 .arraycopy(
714                                                                                 tokenBeforeColon,
715                                                                                 0,
716                                                                                 (tokenBeforeColon = new int[tokenBeforeColonCount * 2]),
717                                                                                 0, tokenBeforeColonCount);
718                                         }
719                                         tokenBeforeColon[tokenBeforeColonCount++] = TokenNamecase;
720                                         indentationLevel += pushControlStatement(TokenNamecase);
721                                         break;
722                                 case TokenNameQUESTION:
723                                         if (tokenBeforeColonCount == tokenBeforeColon.length) {
724                                                 System
725                                                                 .arraycopy(
726                                                                                 tokenBeforeColon,
727                                                                                 0,
728                                                                                 (tokenBeforeColon = new int[tokenBeforeColonCount * 2]),
729                                                                                 0, tokenBeforeColonCount);
730                                         }
731                                         tokenBeforeColon[tokenBeforeColonCount++] = token;
732                                         break;
733                                 case TokenNameswitch:
734                                 case TokenNamefor:
735                                 case TokenNameforeach:
736                                 case TokenNameif:
737                                 case TokenNamewhile:
738                                         if (openParenthesisCount == openParenthesis.length) {
739                                                 System
740                                                                 .arraycopy(
741                                                                                 openParenthesis,
742                                                                                 0,
743                                                                                 (openParenthesis = new int[openParenthesisCount * 2]),
744                                                                                 0, openParenthesisCount);
745                                         }
746                                         openParenthesis[openParenthesisCount++] = 0;
747                                         expectingOpenBrace = true;
748                                         indentationLevel += pushControlStatement(token);
749                                         break;
750                                 case TokenNametry:
751                                         pendingNewlineAfterParen = true;
752                                 case TokenNamecatch:
753                                         // several CATCH statements can be contiguous.
754                                         // a CATCH is encountered pop until first CATCH (if a CATCH
755                                         // follows a TRY it works the same way,
756                                         // as CATCH and TRY are the same token in the stack).
757                                         expectingOpenBrace = true;
758                                         indentationLevel += pushControlStatement(TokenNamecatch);
759                                         break;
760                                 case TokenNamedo:
761                                         expectingOpenBrace = true;
762                                         indentationLevel += pushControlStatement(token);
763                                         nlicsToken = token;
764                                         break;
765                                 case TokenNamenew:
766                                         break;
767                                 case TokenNameLPAREN:
768                                         // if (previousToken == TokenNamesynchronized) {
769                                         // indentationLevel += pushControlStatement(previousToken);
770                                         // } else {
771                                         // Put a space between the previous and current token if the
772                                         // previous token was not a keyword, open paren, logical
773                                         // compliment (eg: !), semi-colon, open brace, close brace,
774                                         // super, or this.
775                                         if (previousCompilableToken != TokenNameLBRACKET
776                                                         && previousToken != TokenNameIdentifier
777                                                         && previousToken != 0
778                                                         && previousToken != TokenNameNOT
779                                                         && previousToken != TokenNameLPAREN
780                                                         && previousToken != TokenNameTWIDDLE
781                                                         && previousToken != TokenNameSEMICOLON
782                                                         && previousToken != TokenNameLBRACE
783                                                         && previousToken != TokenNameRBRACE
784                                                         && previousToken != TokenNamesuper) {
785                                                 // && previousToken != TokenNamethis) {
786                                                 if (!options.compactArrays) {
787                                                         space();
788                                                 }
789                                         }
790                                         // If in a for/if/while statement, increase the parenthesis
791                                         // count
792                                         // for the current openParenthesisCount
793                                         // else increase the count for stand alone parenthesis.
794                                         if (openParenthesisCount > 0)
795                                                 openParenthesis[openParenthesisCount - 1]++;
796                                         else
797                                                 openParenthesis[0]++;
798                                         pendingSpace = false;
799                                         // recognize array declaration for nice output
800                                         if (previousCompilableToken == TokenNamearray) {
801                                                 arrayDeclarationCount++;
802                                                 arrayDeclarationParenthesis[arrayDeclarationCount] = openParenthesis[openParenthesisCount - 1];
803                                                 if (!options.compactArrays) {
804                                                         indentationLevel++;
805                                                         pendingNewLines = 1;
806                                                 }
807                                         }
808                                         // S }
809                                         break;
810                                 case TokenNameRPAREN:
811                                         // check for closing array declaration
812                                         if (arrayDeclarationCount > 0) {
813                                                 if (arrayDeclarationParenthesis[arrayDeclarationCount] == openParenthesis[openParenthesisCount - 1]) {
814                                                         if (previousCompilableToken != TokenNameLPAREN) {
815                                                                 if (!options.compactArrays) {
816                                                                         newLine(1);
817                                                                 }
818                                                         } else if (previousToken == TokenNameCOMMENT_LINE
819                                                                         || previousToken == TokenNameCOMMENT_BLOCK
820                                                                         || previousToken == TokenNameCOMMENT_PHPDOC) {
821                                                                 // prevent to combine comment line and statement line (#1475484)
822                                                                 if (!options.compactArrays) {
823                                                                         newLine(1);
824                                                                 }
825                                                         }
826                                                         if (!options.compactArrays) {
827                                                                 indentationLevel--;
828                                                                 
829                                                         }
830                                                         currentLineIndentationLevel = indentationLevel;
831                                                         pendingNewLines = 0;
832                                                         arrayDeclarationCount--;
833                                                 }
834                                         }
835                                         // Decrease the parenthesis count
836                                         // if there is no more unclosed parenthesis,
837                                         // a new line and indent may be append (depending on the
838                                         // next
839                                         // token).
840                                         if ((openParenthesisCount > 1)
841                                                         && (openParenthesis[openParenthesisCount - 1] > 0)) {
842                                                 openParenthesis[openParenthesisCount - 1]--;
843                                                 if (openParenthesis[openParenthesisCount - 1] <= 0) {
844                                                         pendingNewlineAfterParen = true;
845                                                         inAssignment = false;
846                                                         openParenthesisCount--;
847                                                 }
848                                         } else {
849                                                 openParenthesis[0]--;
850                                         }
851                                         pendingSpace = false;
852                                         break;
853                                 case TokenNameLBRACE:
854                                         if (previousCompilableToken == TokenNameDOLLAR) {
855                                                 dollarBraceCount++;
856                                         } else {
857                                                 if ((previousCompilableToken == TokenNameRBRACKET)
858                                                                 || (previousCompilableToken == TokenNameEQUAL)) {
859                                                         // if (previousCompilableToken == TokenNameRBRACKET)
860                                                         // {
861                                                         inArrayAssignment = true;
862                                                         inAssignment = false;
863                                                 }
864                                                 if (inArrayAssignment) {
865                                                         indentationLevel += pushBlock();
866                                                 } else {
867                                                         // Add new line and increase indentation level after
868                                                         // open brace.
869                                                         pendingNewLines = 1;
870                                                         indentationLevel += pushBlock();
871                                                         inAssignment = false;
872                                                 }
873                                         }
874                                         break;
875                                 case TokenNameRBRACE:
876                                         if (dollarBraceCount > 0) {
877                                                 dollarBraceCount--;
878                                                 break;
879                                         }
880                                         if (previousCompilableToken == TokenNameRPAREN) {
881                                                 pendingSpace = false;
882                                         }
883                                         if (inArrayAssignment) {
884                                                 inArrayAssignment = false;
885                                                 pendingNewLines = 1;
886                                                 indentationLevel += popInclusiveUntilBlock();
887                                         } else {
888                                                 pendingNewLines = 1;
889                                                 indentationLevel += popInclusiveUntilBlock();
890                                                 if (previousCompilableToken == TokenNameRPAREN) {
891                                                         // fix for 1FGDDV6: LFCOM:WIN98 - Weird splitting on
892                                                         // message
893                                                         // expression
894                                                         currentLineBuffer
895                                                                         .append(options.lineSeparatorSequence);
896                                                         increaseLineDelta(options.lineSeparatorSequence.length);
897                                                 }
898                                                 if (constructionsCount > 0) {
899                                                         switch (constructions[constructionsCount - 1]) {
900                                                         case TokenNamefor:
901                                                         case TokenNameforeach:
902                                                                 // indentationLevel += popExclusiveUntilBlock();
903                                                                 // break;
904                                                         case TokenNameswitch:
905                                                         case TokenNameif:
906                                                         case TokenNameelse:
907                                                         case TokenNametry:
908                                                         case TokenNamecatch:
909                                                         case TokenNamefinally:
910                                                         case TokenNamewhile:
911                                                         case TokenNamedo:
912                                                                 // case TokenNamesynchronized :
913                                                                 clearNonBlockIndents = true;
914                                                         default:
915                                                                 break;
916                                                         }
917                                                 }
918                                         }
919                                         break;
920                                 case TokenNameLBRACKET:
921                                         openBracketCount++;
922                                         pendingSpace = false;
923                                         break;
924                                 case TokenNameRBRACKET:
925                                         openBracketCount -= (openBracketCount > 0) ? 1 : 0;
926                                         // if there is no left bracket to close, the right bracket
927                                         // is
928                                         // ignored.
929                                         pendingSpace = false;
930                                         break;
931                                 case TokenNameCOMMA:
932                                         pendingSpace = false;
933                                         if (arrayDeclarationCount > 0) {
934                                                 if (arrayDeclarationParenthesis[arrayDeclarationCount] == openParenthesis[openParenthesisCount - 1]) {
935                                                         // there is no left parenthesis to close in current array declaration (#1475484)
936                                                         if (!options.compactArrays) {
937                                                                 pendingNewLines = 1;                                                            
938                                                         }
939                                                 }
940                                         }
941                                         break;
942                                 case TokenNameDOT:
943                                         if (!options.compactStringConcatenation) {
944                                                 space();
945                                         }
946                                         pendingSpace = false;
947                                         break;
948                                 case TokenNameSEMICOLON:
949                                         // Do not generate line terminators in the definition of
950                                         // the for statement.
951                                         // if not in this case, jump a line and reduce indentation
952                                         // after
953                                         // the brace
954                                         // if the block it closes belongs to a conditional statement
955                                         // (if,
956                                         // while, do...).
957                                         if (openParenthesisCount <= 1) {
958                                                 pendingNewLines = 1;
959                                                 if (expectingOpenBrace) {
960                                                         clearNonBlockIndents = true;
961                                                         expectingOpenBrace = false;
962                                                 }
963                                         }
964                                         inAssignment = false;
965                                         pendingSpace = false;
966                                         break;
967                                 case TokenNamePLUS_PLUS:
968                                 case TokenNameMINUS_MINUS:
969                                         // Do not put a space between a post-increment/decrement
970                                         // and the identifier being modified.
971                                         if (previousToken == TokenNameIdentifier
972                                                         || previousToken == TokenNameRBRACKET
973                                                         || previousToken == TokenNameVariable) {
974                                                 pendingSpace = false;
975                                         }
976                                         break;
977                                 case TokenNamePLUS:
978                                         // previously ADDITION
979                                 case TokenNameMINUS:
980                                         // Handle the unary operators plus and minus via a flag
981                                         if (!isLiteralToken(previousToken)
982                                                         && previousToken != TokenNameIdentifier
983                                                         && previousToken != TokenNameRPAREN
984                                                         && previousToken != TokenNameRBRACKET) {
985                                                 unarySignModifier = 1;
986                                         }
987                                         break;
988                                 case TokenNameCOLON:
989                                         // In a switch/case statement, add a newline & indent
990                                         // when a colon is encountered.
991                                         if (tokenBeforeColonCount > 0) {
992                                                 if (tokenBeforeColon[tokenBeforeColonCount - 1] == TokenNamecase) {
993                                                         pendingNewLines = 1;
994                                                 }
995                                                 tokenBeforeColonCount--;
996                                         }
997                                         break;
998                                 case TokenNameEQUAL:
999                                         inAssignment = true;
1000                                         break;
1001                                 case Scanner.TokenNameCOMMENT_LINE:
1002                                         pendingNewLines = 1;
1003                                         //if (inAssignment) {
1004                                         //      currentLineIndentationLevel++;
1005                                         //}
1006                                         break; // a line is always inserted after a one-line
1007                                                         // comment
1008                                 case Scanner.TokenNameCOMMENT_PHPDOC:
1009                                 case Scanner.TokenNameCOMMENT_BLOCK:
1010                                         currentCommentOffset = getCurrentCommentOffset();
1011                                         pendingNewLines = 1;
1012                                         break;
1013                                 case Scanner.TokenNameWHITESPACE:
1014                                         if (!phpTagAndWhitespace) {
1015                                                 // Count the number of line terminators in the
1016                                                 // whitespace so
1017                                                 // line spacing can be preserved near comments.
1018                                                 char[] source = scanner.source;
1019                                                 newLinesInWhitespace = 0;
1020                                                 for (int i = scanner.startPosition, max = scanner.currentPosition; i < max; i++) {
1021                                                         if (source[i] == '\r') {
1022                                                                 if (i < max - 1) {
1023                                                                         if (source[++i] == '\n') {
1024                                                                                 newLinesInWhitespace++;
1025                                                                         } else {
1026                                                                                 newLinesInWhitespace++;
1027                                                                         }
1028                                                                 } else {
1029                                                                         newLinesInWhitespace++;
1030                                                                 }
1031                                                         } else if (source[i] == '\n') {
1032                                                                 newLinesInWhitespace++;
1033                                                         }
1034                                                 }
1035                                                 increaseLineDelta(scanner.startPosition
1036                                                                 - scanner.currentPosition);
1037                                                 break;
1038                                         }
1039                                         // case TokenNameHTML :
1040                                         // // Add the next token to the formatted source string.
1041                                         // // outputCurrentToken(token);
1042                                         // int startPosition = scanner.startPosition;
1043                                         // flushBuffer();
1044                                         // for (int i = startPosition, max =
1045                                         // scanner.currentPosition; i <
1046                                         // max; i++) {
1047                                         // char currentCharacter = scanner.source[i];
1048                                         // updateMappedPositions(i);
1049                                         // currentLineBuffer.append(currentCharacter);
1050                                         // }
1051                                         // break;
1052                                 default:
1053                                         if ((token == TokenNameIdentifier) || isLiteralToken(token)
1054                                                         || token == TokenNamesuper) {
1055                                                 // || token == TokenNamethis) {
1056                                                 // Do not put a space between a unary operator
1057                                                 // (eg: ++, --, +, -) and the identifier being modified.
1058                                                 if (previousToken == TokenNamePLUS_PLUS
1059                                                                 || previousToken == TokenNameMINUS_MINUS
1060                                                                 || (previousToken == TokenNameMINUS_GREATER && options.compactDereferencingMode) // ->
1061                                                                 || (previousToken == TokenNamePLUS && unarySignModifier > 0)
1062                                                                 || (previousToken == TokenNameMINUS && unarySignModifier > 0)) {
1063                                                         pendingSpace = false;
1064                                                 }
1065                                                 unarySignModifier = 0;
1066                                         }
1067                                         break;
1068                                 }
1069                                 // Do not output whitespace tokens.
1070                                 if (token != Scanner.TokenNameWHITESPACE || phpTagAndWhitespace) {
1071                                         /*
1072                                          * Add pending space to the formatted source string. Do not
1073                                          * output a space under the following circumstances: 1) this
1074                                          * is the first pass 2) previous token is an open paren 3)
1075                                          * previous token is a period 4) previous token is the
1076                                          * logical compliment (eg: !) 5) previous token is the
1077                                          * bitwise compliment (eg: ~) 6) previous token is the open
1078                                          * bracket (eg: [) 7) in an assignment statement, if the
1079                                          * previous token is an open brace or the current token is a
1080                                          * close brace 8) previous token is a single line comment 9)
1081                                          * current token is a '->'
1082                                          */
1083                                         if (token == TokenNameMINUS_GREATER
1084                                                         && options.compactDereferencingMode)
1085                                                 pendingSpace = false;
1086
1087                                         boolean openAndCloseBrace = previousCompilableToken == TokenNameLBRACE
1088                                                         && token == TokenNameRBRACE;
1089                                         if (pendingSpace
1090                                                         && insertSpaceAfter(previousToken)
1091                                                         && !(inAssignment && (previousToken == TokenNameLBRACE || token == TokenNameRBRACE))
1092                                                         && previousToken != Scanner.TokenNameCOMMENT_LINE) {
1093                                                 if ((!(options.compactAssignmentMode && token == TokenNameEQUAL))
1094                                                                 && !openAndCloseBrace)
1095                                                         space();
1096                                         }
1097                                         // Add the next token to the formatted source string.
1098                                         outputCurrentToken(token);
1099                                         if (token == Scanner.TokenNameCOMMENT_LINE
1100                                                         && openParenthesisCount > 1) {
1101                                                 pendingNewLines = 0;
1102                                                 currentLineBuffer.append(options.lineSeparatorSequence);
1103                                                 increaseLineDelta(options.lineSeparatorSequence.length);
1104                                         }
1105                                         pendingSpace = true;
1106                                 }
1107                                 // Whitespace tokens do not need to be remembered.
1108                                 if (token != Scanner.TokenNameWHITESPACE || phpTagAndWhitespace) {
1109                                         previousToken = token;
1110                                         if (token != Scanner.TokenNameCOMMENT_BLOCK
1111                                                         && token != Scanner.TokenNameCOMMENT_LINE
1112                                                         && token != Scanner.TokenNameCOMMENT_PHPDOC) {
1113                                                 previousCompilableToken = token;
1114                                         }
1115                                 }
1116                         }
1117                         output(copyRemainingSource());
1118                         flushBuffer();
1119                         // dump the last token of the source in the formatted output.
1120                 } catch (InvalidInputException e) {
1121                         output(copyRemainingSource());
1122                         flushBuffer();
1123                         // dump the last token of the source in the formatted output.
1124                 }
1125         }
1126
1127         /**
1128          * Formats the char array <code>sourceString</code>, and returns a string
1129          * containing the formatted version.
1130          * 
1131          * @return the formatted ouput.
1132          */
1133         public String formatSourceString(String sourceString) {
1134                 char[] sourceChars = sourceString.toCharArray();
1135                 formattedSource = new StringBuffer(sourceChars.length);
1136                 scanner.setSource(sourceChars);
1137                 format();
1138                 return formattedSource.toString();
1139         }
1140
1141         /**
1142          * Formats the char array <code>sourceString</code>, and returns a string
1143          * containing the formatted version.
1144          * 
1145          * @param string
1146          *            the string to format
1147          * @param indentationLevel
1148          *            the initial indentation level
1149          * @return the formatted ouput.
1150          */
1151         public String format(String string, int indentationLevel) {
1152                 return format(string, indentationLevel, (int[]) null);
1153         }
1154
1155         /**
1156          * Formats the char array <code>sourceString</code>, and returns a string
1157          * containing the formatted version. The positions array is modified to
1158          * contain the mapped positions.
1159          * 
1160          * @param string
1161          *            the string to format
1162          * @param indentationLevel
1163          *            the initial indentation level
1164          * @param positions
1165          *            the array of positions to map
1166          * @return the formatted ouput.
1167          */
1168         public String format(String string, int indentationLevel, int[] positions) {
1169                 return this.format(string, indentationLevel, positions, null);
1170         }
1171
1172         public String format(String string, int indentationLevel, int[] positions,
1173                         String lineSeparator) {
1174                 if (lineSeparator != null) {
1175                         this.options.setLineSeparator(lineSeparator);
1176                 }
1177                 if (positions != null) {
1178                         this.setPositionsToMap(positions);
1179                         this.setInitialIndentationLevel(indentationLevel);
1180                         String formattedString = this.formatSourceString(string);
1181                         int[] mappedPositions = this.getMappedPositions();
1182                         System
1183                                         .arraycopy(mappedPositions, 0, positions, 0,
1184                                                         positions.length);
1185                         return formattedString;
1186                 } else {
1187                         this.setInitialIndentationLevel(indentationLevel);
1188                         return this.formatSourceString(string);
1189                 }
1190         }
1191
1192         /**
1193          * Formats the char array <code>sourceString</code>, and returns a string
1194          * containing the formatted version. The initial indentation level is 0.
1195          * 
1196          * @param string
1197          *            the string to format
1198          * @return the formatted ouput.
1199          */
1200         public String format(String string) {
1201                 return this.format(string, 0, (int[]) null);
1202         }
1203
1204         /**
1205          * Formats a given source string, starting indenting it at a particular
1206          * depth and using the given options
1207          * 
1208          * @deprecated backport 1.0 internal functionality
1209          */
1210         public static String format(String sourceString,
1211                         int initialIndentationLevel, ConfigurableOption[] options) {
1212                 CodeFormatter formatter = new CodeFormatter(options);
1213                 formatter.setInitialIndentationLevel(initialIndentationLevel);
1214                 return formatter.formatSourceString(sourceString);
1215         }
1216
1217         /**
1218          * Returns the number of characters and tab char between the beginning of
1219          * the line and the beginning of the comment.
1220          */
1221         private int getCurrentCommentOffset() {
1222                 int linePtr = scanner.linePtr;
1223                 // if there is no beginning of line, return 0.
1224                 if (linePtr < 0)
1225                         return 0;
1226                 int offset = 0;
1227                 int beginningOfLine = scanner.lineEnds[linePtr];
1228                 int currentStartPosition = scanner.startPosition;
1229                 char[] source = scanner.source;
1230                 // find the position of the beginning of the line containing the comment
1231                 while (beginningOfLine > currentStartPosition) {
1232                         if (linePtr > 0) {
1233                                 beginningOfLine = scanner.lineEnds[--linePtr];
1234                         } else {
1235                                 beginningOfLine = 0;
1236                                 break;
1237                         }
1238                 }
1239                 for (int i = currentStartPosition - 1; i >= beginningOfLine; i--) {
1240                         char currentCharacter = source[i];
1241                         switch (currentCharacter) {
1242                         case '\t':
1243                                 offset += options.tabSize;
1244                                 break;
1245                         case ' ':
1246                                 offset++;
1247                                 break;
1248                         case '\r':
1249                         case '\n':
1250                                 break;
1251                         default:
1252                                 return offset;
1253                         }
1254                 }
1255                 return offset;
1256         }
1257
1258         /**
1259          * Returns an array of descriptions for the configurable options. The
1260          * descriptions may be changed and passed back to a different compiler.
1261          * 
1262          * @deprecated backport 1.0 internal functionality
1263          */
1264         public static ConfigurableOption[] getDefaultOptions(Locale locale) {
1265                 String componentName = CodeFormatter.class.getName();
1266                 FormatterOptions options = new FormatterOptions();
1267                 return new ConfigurableOption[] {
1268                                 new ConfigurableOption(componentName, "newline.openingBrace",
1269                                                 locale, options.newLineBeforeOpeningBraceMode ? 0 : 1),
1270                                 //$NON-NLS-1$
1271                                 new ConfigurableOption(componentName,
1272                                                 "newline.controlStatement", locale,
1273                                                 options.newlineInControlStatementMode ? 0 : 1),
1274                                 //$NON-NLS-1$
1275                                 new ConfigurableOption(componentName, "newline.clearAll",
1276                                                 locale, options.clearAllBlankLinesMode ? 0 : 1),
1277                                 //$NON-NLS-1$
1278                                 // new ConfigurableOption(componentName, "newline.elseIf",
1279                                 // locale,
1280                                 // options.compactElseIfMode ? 0 : 1), //$NON-NLS-1$
1281                                 new ConfigurableOption(componentName, "newline.emptyBlock",
1282                                                 locale, options.newLineInEmptyBlockMode ? 0 : 1),
1283                                 //$NON-NLS-1$
1284                                 new ConfigurableOption(componentName, "line.split", locale,
1285                                                 options.maxLineLength),
1286                                 //$NON-NLS-1$
1287                                 new ConfigurableOption(componentName,
1288                                                 "style.compactAssignment", locale,
1289                                                 options.compactAssignmentMode ? 0 : 1),
1290                                 //$NON-NLS-1$
1291                                 new ConfigurableOption(componentName, "tabulation.char",
1292                                                 locale, options.indentWithTab ? 0 : 1),
1293                                 //$NON-NLS-1$
1294                                 new ConfigurableOption(componentName,
1295                                                 "tabulation.size", locale, options.tabSize) //$NON-NLS-1$
1296                 };
1297         }
1298
1299         /**
1300          * Returns the array of mapped positions. Returns null is no positions have
1301          * been set.
1302          * 
1303          * @return int[]
1304          * @deprecated There is no need to retrieve the mapped positions anymore.
1305          */
1306         public int[] getMappedPositions() {
1307                 if (null != mappedPositions) {
1308                         for (int i = 0; i < mappedPositions.length; i++) {
1309                                 if (mappedPositions[i] >= formattedSource.length()) {
1310                                         mappedPositions[i] = formattedSource.length() - 1;
1311                                 }
1312                         }
1313                 }
1314                 return mappedPositions;
1315         }
1316
1317         /**
1318          * Returns the priority of the token given as argument <br>
1319          * The most prioritary the token is, the smallest the return value is.
1320          * 
1321          * @return the priority of <code>token</code>
1322          * @param token
1323          *            the token of which the priority is requested
1324          */
1325         private static int getTokenPriority(int token) {
1326                 switch (token) {
1327                 case TokenNameextends:
1328                         // case TokenNameimplements :
1329                         // case TokenNamethrows :
1330                         return 10;
1331                 case TokenNameSEMICOLON:
1332                         // ;
1333                         return 20;
1334                 case TokenNameCOMMA:
1335                         // ,
1336                         return 25;
1337                 case TokenNameEQUAL:
1338                         // =
1339                         return 30;
1340                 case TokenNameAND_AND:
1341                         // &&
1342                 case TokenNameOR_OR:
1343                         // ||
1344                         return 40;
1345                 case TokenNameQUESTION:
1346                         // ?
1347                 case TokenNameCOLON:
1348                         // :
1349                         return 50; // it's better cutting on ?: than on ;
1350                 case TokenNameEQUAL_EQUAL:
1351                         // ==
1352                 case TokenNameEQUAL_EQUAL_EQUAL:
1353                         // ===
1354                 case TokenNameNOT_EQUAL:
1355                         // !=
1356                 case TokenNameNOT_EQUAL_EQUAL:
1357                         // !=
1358                         return 60;
1359                 case TokenNameLESS:
1360                         // <
1361                 case TokenNameLESS_EQUAL:
1362                         // <=
1363                 case TokenNameGREATER:
1364                         // >
1365                 case TokenNameGREATER_EQUAL:
1366                         // >=
1367                         // case TokenNameinstanceof : // instanceof
1368                         return 70;
1369                 case TokenNamePLUS:
1370                         // +
1371                 case TokenNameMINUS:
1372                         // -
1373                         return 80;
1374                 case TokenNameMULTIPLY:
1375                         // *
1376                 case TokenNameDIVIDE:
1377                         // /
1378                 case TokenNameREMAINDER:
1379                         // %
1380                         return 90;
1381                 case TokenNameLEFT_SHIFT:
1382                         // <<
1383                 case TokenNameRIGHT_SHIFT:
1384                         // >>
1385                         // case TokenNameUNSIGNED_RIGHT_SHIFT : // >>>
1386                         return 100;
1387                 case TokenNameAND:
1388                         // &
1389                 case TokenNameOR:
1390                         // |
1391                 case TokenNameXOR:
1392                         // ^
1393                         return 110;
1394                 case TokenNameMULTIPLY_EQUAL:
1395                         // *=
1396                 case TokenNameDIVIDE_EQUAL:
1397                         // /=
1398                 case TokenNameREMAINDER_EQUAL:
1399                         // %=
1400                 case TokenNamePLUS_EQUAL:
1401                         // +=
1402                 case TokenNameMINUS_EQUAL:
1403                         // -=
1404                 case TokenNameLEFT_SHIFT_EQUAL:
1405                         // <<=
1406                 case TokenNameRIGHT_SHIFT_EQUAL:
1407                         // >>=
1408                         // case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>=
1409                 case TokenNameAND_EQUAL:
1410                         // &=
1411                 case TokenNameXOR_EQUAL:
1412                         // ^=
1413                 case TokenNameOR_EQUAL:
1414                         // .=
1415                 case TokenNameDOT_EQUAL:
1416                         // |=
1417                         return 120;
1418                 case TokenNameDOT:
1419                         // .
1420                         return 130;
1421                 default:
1422                         return Integer.MAX_VALUE;
1423                 }
1424         }
1425
1426         /**
1427          * Handles the exception raised when an invalid token is encountered.
1428          * Returns true if the exception has been handled, false otherwise.
1429          */
1430         private boolean handleInvalidToken(Exception e) {
1431                 if (e.getMessage().equals(Scanner.INVALID_CHARACTER_CONSTANT)
1432                                 || e.getMessage().equals(Scanner.INVALID_CHAR_IN_STRING)
1433                                 || e.getMessage().equals(Scanner.INVALID_ESCAPE)) {
1434                         return true;
1435                 }
1436                 return false;
1437         }
1438
1439         private final void increaseGlobalDelta(int offset) {
1440                 globalDelta += offset;
1441         }
1442
1443         private final void increaseLineDelta(int offset) {
1444                 lineDelta += offset;
1445         }
1446
1447         private final void increaseSplitDelta(int offset) {
1448                 splitDelta += offset;
1449         }
1450
1451         /**
1452          * Returns true if a space has to be inserted after <code>operator</code>
1453          * false otherwise.
1454          */
1455         private boolean insertSpaceAfter(int token) {
1456                 switch (token) {
1457                 case TokenNameLPAREN:
1458                 case TokenNameNOT:
1459                 case TokenNameTWIDDLE:
1460                 case 0:
1461                         // no token
1462                 case TokenNameWHITESPACE:
1463                 case TokenNameLBRACKET:
1464                 case TokenNameDOLLAR:
1465                 case Scanner.TokenNameCOMMENT_LINE:
1466                         return false;
1467                 case TokenNameDOT:
1468                         return !options.compactStringConcatenation;
1469                 default:
1470                         return true;
1471                 }
1472         }
1473
1474         /**
1475          * Returns true if a space has to be inserted before <code>operator</code>
1476          * false otherwise. <br>
1477          * Cannot be static as it uses the code formatter options (to know if the
1478          * compact assignment mode is on).
1479          */
1480         private boolean insertSpaceBefore(int token) {
1481                 switch (token) {
1482                 case TokenNameEQUAL:
1483                         return (!options.compactAssignmentMode);
1484                 default:
1485                         return false;
1486                 }
1487         }
1488
1489         private static boolean isComment(int token) {
1490                 boolean result = token == Scanner.TokenNameCOMMENT_BLOCK
1491                                 || token == Scanner.TokenNameCOMMENT_LINE
1492                                 || token == Scanner.TokenNameCOMMENT_PHPDOC;
1493                 return result;
1494         }
1495
1496         private static boolean isLiteralToken(int token) {
1497                 boolean result = token == TokenNameIntegerLiteral
1498                 // || token == TokenNameLongLiteral
1499                                 // || token == TokenNameFloatingPointLiteral
1500                                 || token == TokenNameDoubleLiteral
1501                                 // || token == TokenNameCharacterLiteral
1502                                 || token == TokenNameStringDoubleQuote;
1503                 return result;
1504         }
1505
1506         /**
1507          * If the length of <code>oneLineBuffer</code> exceeds
1508          * <code>maxLineLength</code>, it is split and the result is dumped in
1509          * <code>formattedSource</code>
1510          * 
1511          * @param newLineCount
1512          *            the number of new lines to append
1513          */
1514         private void newLine(int newLineCount) {
1515                 // format current line
1516                 splitDelta = 0;
1517                 beginningOfLineIndex = formattedSource.length();
1518                 String currentLine = currentLineBuffer.toString();
1519                 if (containsOpenCloseBraces) {
1520                         containsOpenCloseBraces = false;
1521                         outputLine(currentLine, false, indentationLevelForOpenCloseBraces,
1522                                         0, -1, null, 0);
1523                         indentationLevelForOpenCloseBraces = currentLineIndentationLevel;
1524                 } else {
1525                         outputLine(currentLine, false, currentLineIndentationLevel, 0, -1,
1526                                         null, 0);
1527                 }
1528                 // dump line break(s)
1529                 for (int i = 0; i < newLineCount; i++) {
1530                         formattedSource.append(options.lineSeparatorSequence);
1531                         increaseSplitDelta(options.lineSeparatorSequence.length);
1532                 }
1533                 // reset formatter for next line
1534                 int currentLength = currentLine.length();
1535                 currentLineBuffer = new StringBuffer(
1536                                 currentLength > maxLineSize ? maxLineSize = currentLength
1537                                                 : maxLineSize);
1538                 increaseGlobalDelta(splitDelta);
1539                 increaseGlobalDelta(lineDelta);
1540                 lineDelta = 0;
1541                 currentLineIndentationLevel = initialIndentationLevel;
1542         }
1543
1544         private String operatorString(int operator) {
1545                 switch (operator) {
1546                 case TokenNameextends:
1547                         return "extends"; //$NON-NLS-1$
1548                         // case TokenNameimplements :
1549                         // return "implements"; //$NON-NLS-1$
1550                         //
1551                         // case TokenNamethrows :
1552                         // return "throws"; //$NON-NLS-1$
1553                 case TokenNameSEMICOLON:
1554                         // ;
1555                         return ";"; //$NON-NLS-1$
1556                 case TokenNameCOMMA:
1557                         // ,
1558                         return ","; //$NON-NLS-1$
1559                 case TokenNameEQUAL:
1560                         // =
1561                         return "="; //$NON-NLS-1$
1562                 case TokenNameAND_AND:
1563                         // && (15.22)
1564                         return "&&"; //$NON-NLS-1$
1565                 case TokenNameOR_OR:
1566                         // || (15.23)
1567                         return "||"; //$NON-NLS-1$
1568                 case TokenNameQUESTION:
1569                         // ? (15.24)
1570                         return "?"; //$NON-NLS-1$
1571                 case TokenNameCOLON:
1572                         // : (15.24)
1573                         return ":"; //$NON-NLS-1$
1574                 case TokenNamePAAMAYIM_NEKUDOTAYIM:
1575                         // : (15.24)
1576                         return "::"; //$NON-NLS-1$
1577                 case TokenNameEQUAL_EQUAL:
1578                         // == (15.20, 15.20.1, 15.20.2, 15.20.3)
1579                         return "=="; //$NON-NLS-1$
1580                 case TokenNameEQUAL_EQUAL_EQUAL:
1581                         // == (15.20, 15.20.1, 15.20.2, 15.20.3)
1582                         return "==="; //$NON-NLS-1$
1583                 case TokenNameEQUAL_GREATER:
1584                         // -= (15.25.2)
1585                         return "=>"; //$NON-NLS-1$
1586                 case TokenNameNOT_EQUAL:
1587                         // != (15.20, 15.20.1, 15.20.2, 15.20.3)
1588                         return "!="; //$NON-NLS-1$
1589                 case TokenNameNOT_EQUAL_EQUAL:
1590                         // != (15.20, 15.20.1, 15.20.2, 15.20.3)
1591                         return "!=="; //$NON-NLS-1$
1592                 case TokenNameLESS:
1593                         // < (15.19.1)
1594                         return "<"; //$NON-NLS-1$
1595                 case TokenNameLESS_EQUAL:
1596                         // <= (15.19.1)
1597                         return "<="; //$NON-NLS-1$
1598                 case TokenNameGREATER:
1599                         // > (15.19.1)
1600                         return ">"; //$NON-NLS-1$
1601                 case TokenNameGREATER_EQUAL:
1602                         // >= (15.19.1)
1603                         return ">="; //$NON-NLS-1$
1604                         // case TokenNameinstanceof : // instanceof
1605                         // return "instanceof"; //$NON-NLS-1$
1606                 case TokenNamePLUS:
1607                         // + (15.17, 15.17.2)
1608                         return "+"; //$NON-NLS-1$
1609                 case TokenNameMINUS:
1610                         // - (15.17.2)
1611                         return "-"; //$NON-NLS-1$
1612                 case TokenNameMULTIPLY:
1613                         // * (15.16.1)
1614                         return "*"; //$NON-NLS-1$
1615                 case TokenNameDIVIDE:
1616                         // / (15.16.2)
1617                         return "/"; //$NON-NLS-1$
1618                 case TokenNameREMAINDER:
1619                         // % (15.16.3)
1620                         return "%"; //$NON-NLS-1$
1621                 case TokenNameLEFT_SHIFT:
1622                         // << (15.18)
1623                         return "<<"; //$NON-NLS-1$
1624                 case TokenNameRIGHT_SHIFT:
1625                         // >> (15.18)
1626                         return ">>"; //$NON-NLS-1$
1627                         // case TokenNameUNSIGNED_RIGHT_SHIFT : // >>> (15.18)
1628                         // return ">>>"; //$NON-NLS-1$
1629                 case TokenNameAND:
1630                         // & (15.21, 15.21.1, 15.21.2)
1631                         return "&"; //$NON-NLS-1$
1632                 case TokenNameOR:
1633                         // | (15.21, 15.21.1, 15.21.2)
1634                         return "|"; //$NON-NLS-1$
1635                 case TokenNameXOR:
1636                         // ^ (15.21, 15.21.1, 15.21.2)
1637                         return "^"; //$NON-NLS-1$
1638                 case TokenNameMULTIPLY_EQUAL:
1639                         // *= (15.25.2)
1640                         return "*="; //$NON-NLS-1$
1641                 case TokenNameDIVIDE_EQUAL:
1642                         // /= (15.25.2)
1643                         return "/="; //$NON-NLS-1$
1644                 case TokenNameREMAINDER_EQUAL:
1645                         // %= (15.25.2)
1646                         return "%="; //$NON-NLS-1$
1647                 case TokenNamePLUS_EQUAL:
1648                         // += (15.25.2)
1649                         return "+="; //$NON-NLS-1$
1650                 case TokenNameMINUS_EQUAL:
1651                         // -= (15.25.2)
1652                         return "-="; //$NON-NLS-1$
1653                 case TokenNameMINUS_GREATER:
1654                         // -= (15.25.2)
1655                         return "->"; //$NON-NLS-1$
1656                 case TokenNameLEFT_SHIFT_EQUAL:
1657                         // <<= (15.25.2)
1658                         return "<<="; //$NON-NLS-1$
1659                 case TokenNameRIGHT_SHIFT_EQUAL:
1660                         // >>= (15.25.2)
1661                         return ">>="; //$NON-NLS-1$
1662                         // case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>= (15.25.2)
1663                         // return ">>>="; //$NON-NLS-1$
1664                 case TokenNameAND_EQUAL:
1665                         // &= (15.25.2)
1666                         return "&="; //$NON-NLS-1$
1667                 case TokenNameXOR_EQUAL:
1668                         // ^= (15.25.2)
1669                         return "^="; //$NON-NLS-1$
1670                 case TokenNameOR_EQUAL:
1671                         // |= (15.25.2)
1672                         return "|="; //$NON-NLS-1$
1673                 case TokenNameDOT_EQUAL:
1674                         // .=
1675                         return ".="; //$NON-NLS-1$
1676                 case TokenNameDOT:
1677                         // .
1678                         return "."; //$NON-NLS-1$
1679                 default:
1680                         return ""; //$NON-NLS-1$
1681                 }
1682         }
1683
1684         /**
1685          * Appends <code>stringToOutput</code> to the formatted output. <br>
1686          * If it contains \n, append a LINE_SEPARATOR and indent after it.
1687          */
1688         private void output(String stringToOutput) {
1689                 char currentCharacter;
1690                 for (int i = 0, max = stringToOutput.length(); i < max; i++) {
1691                         currentCharacter = stringToOutput.charAt(i);
1692                         if (currentCharacter != '\t') {
1693                                 currentLineBuffer.append(currentCharacter);
1694                         }
1695                 }
1696         }
1697
1698         private void outputCurrentTokenWithoutIndent(int token, int newLineCount) {
1699                 newLine(newLineCount);
1700                 formattedSource.append(scanner.source, scanner.startPosition,
1701                                 scanner.currentPosition - scanner.startPosition);
1702         }
1703
1704         /**
1705          * Appends <code>token</code> to the formatted output. <br>
1706          * If it contains <code>\n</code>, append a LINE_SEPARATOR and indent
1707          * after it.
1708          */
1709         private void outputCurrentToken(int token) {
1710                 char[] source = scanner.source;
1711                 int startPosition = scanner.startPosition;
1712                 switch (token) {
1713                 case Scanner.TokenNameCOMMENT_PHPDOC:
1714                 case Scanner.TokenNameCOMMENT_BLOCK:
1715                 case Scanner.TokenNameCOMMENT_LINE:
1716                         boolean endOfLine = false;
1717                         int currentCommentOffset = getCurrentCommentOffset();
1718                         int beginningOfLineSpaces = 0;
1719                         endOfLine = false;
1720                         currentCommentOffset = getCurrentCommentOffset();
1721                         beginningOfLineSpaces = 0;
1722                         boolean pendingCarriageReturn = false;
1723                         for (int i = startPosition, max = scanner.currentPosition; i < max; i++) {
1724                                 char currentCharacter = source[i];
1725                                 updateMappedPositions(i);
1726                                 switch (currentCharacter) {
1727                                 case '\r':
1728                                         pendingCarriageReturn = true;
1729                                         endOfLine = true;
1730                                         break;
1731                                 case '\n':
1732                                         if (pendingCarriageReturn) {
1733                                                 increaseGlobalDelta(options.lineSeparatorSequence.length - 2);
1734                                         } else {
1735                                                 increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
1736                                         }
1737                                         pendingCarriageReturn = false;
1738                                         currentLineBuffer.append(options.lineSeparatorSequence);
1739                                         beginningOfLineSpaces = 0;
1740                                         endOfLine = true;
1741                                         break;
1742                                 case '\t':
1743                                         if (pendingCarriageReturn) {
1744                                                 pendingCarriageReturn = false;
1745                                                 increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
1746                                                 currentLineBuffer.append(options.lineSeparatorSequence);
1747                                                 beginningOfLineSpaces = 0;
1748                                                 endOfLine = true;
1749                                         }
1750                                         if (endOfLine) {
1751                                                 // we remove a maximum of currentCommentOffset
1752                                                 // characters (tabs
1753                                                 // are converted to space numbers).
1754                                                 beginningOfLineSpaces += options.tabSize;
1755                                                 if (beginningOfLineSpaces > currentCommentOffset) {
1756                                                         currentLineBuffer.append(currentCharacter);
1757                                                 } else {
1758                                                         increaseGlobalDelta(-1);
1759                                                 }
1760                                         } else {
1761                                                 currentLineBuffer.append(currentCharacter);
1762                                         }
1763                                         break;
1764                                 case ' ':
1765                                         if (pendingCarriageReturn) {
1766                                                 pendingCarriageReturn = false;
1767                                                 increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
1768                                                 currentLineBuffer.append(options.lineSeparatorSequence);
1769                                                 beginningOfLineSpaces = 0;
1770                                                 endOfLine = true;
1771                                         }
1772                                         if (endOfLine) {
1773                                                 // we remove a maximum of currentCommentOffset
1774                                                 // characters (tabs
1775                                                 // are converted to space numbers).
1776                                                 beginningOfLineSpaces++;
1777                                                 if (beginningOfLineSpaces > currentCommentOffset) {
1778                                                         currentLineBuffer.append(currentCharacter);
1779                                                 } else {
1780                                                         increaseGlobalDelta(-1);
1781                                                 }
1782                                         } else {
1783                                                 currentLineBuffer.append(currentCharacter);
1784                                         }
1785                                         break;
1786                                 default:
1787                                         if (pendingCarriageReturn) {
1788                                                 pendingCarriageReturn = false;
1789                                                 increaseGlobalDelta(options.lineSeparatorSequence.length - 1);
1790                                                 currentLineBuffer.append(options.lineSeparatorSequence);
1791                                                 beginningOfLineSpaces = 0;
1792                                                 endOfLine = true;
1793                                         } else {
1794                                                 beginningOfLineSpaces = 0;
1795                                                 currentLineBuffer.append(currentCharacter);
1796                                                 endOfLine = false;
1797                                         }
1798                                 }
1799                         }
1800                         updateMappedPositions(scanner.currentPosition - 1);
1801                         multipleLineCommentCounter++;
1802                         break;
1803                 default:
1804                         for (int i = startPosition, max = scanner.currentPosition; i < max; i++) {
1805                                 char currentCharacter = source[i];
1806                                 updateMappedPositions(i);
1807                                 currentLineBuffer.append(currentCharacter);
1808                         }
1809                 }
1810         }
1811
1812         /**
1813          * Outputs <code>currentString</code>:<br>
1814          * <ul>
1815          * <li>If its length is < maxLineLength, output
1816          * <li>Otherwise it is split.
1817          * </ul>
1818          * 
1819          * @param currentString
1820          *            string to output
1821          * @param preIndented
1822          *            whether the string to output was pre-indented
1823          * @param depth
1824          *            number of indentation to put in front of
1825          *            <code>currentString</code>
1826          * @param operator
1827          *            value of the operator belonging to <code>currentString</code>.
1828          */
1829         private void outputLine(String currentString, boolean preIndented,
1830                         int depth, int operator, int substringIndex,
1831                         int[] startSubstringIndexes, int offsetInGlobalLine) {
1832                 boolean emptyFirstSubString = false;
1833                 String operatorString = operatorString(operator);
1834                 boolean placeOperatorBehind = !breakLineBeforeOperator(operator);
1835                 boolean placeOperatorAhead = !placeOperatorBehind;
1836                 // dump prefix operator?
1837                 if (placeOperatorAhead) {
1838                         if (!preIndented) {
1839                                 dumpTab(depth);
1840                                 preIndented = true;
1841                         }
1842                         if (operator != 0) {
1843                                 if (insertSpaceBefore(operator)) {
1844                                         formattedSource.append(' ');
1845                                         increaseSplitDelta(1);
1846                                 }
1847                                 formattedSource.append(operatorString);
1848                                 increaseSplitDelta(operatorString.length());
1849                                 if (insertSpaceAfter(operator)
1850                                                 && operator != TokenNameimplements
1851                                                 && operator != TokenNameextends) {
1852                                         // && operator != TokenNamethrows) {
1853                                         formattedSource.append(' ');
1854                                         increaseSplitDelta(1);
1855                                 }
1856                         }
1857                 }
1858                 SplitLine splitLine = null;
1859                 if (options.maxLineLength == 0
1860                                 || getLength(currentString, depth) < options.maxLineLength
1861                                 || (splitLine = split(currentString, offsetInGlobalLine)) == null) {
1862                         // depending on the type of operator, outputs new line before of
1863                         // after
1864                         // dumping it
1865                         // indent before postfix operator
1866                         // indent also when the line cannot be split
1867                         if (operator == TokenNameextends || operator == TokenNameimplements) {
1868                                 // || operator == TokenNamethrows) {
1869                                 formattedSource.append(' ');
1870                                 increaseSplitDelta(1);
1871                         }
1872                         if (placeOperatorBehind) {
1873                                 if (!preIndented) {
1874                                         dumpTab(depth);
1875                                 }
1876                         }
1877                         int max = currentString.length();
1878                         if (multipleLineCommentCounter != 0) {
1879                                 try {
1880                                         BufferedReader reader = new BufferedReader(
1881                                                         new StringReader(currentString));
1882                                         String line = reader.readLine();
1883                                         while (line != null) {
1884                                                 updateMappedPositionsWhileSplitting(
1885                                                                 beginningOfLineIndex, beginningOfLineIndex
1886                                                                                 + line.length()
1887                                                                                 + options.lineSeparatorSequence.length);
1888                                                 formattedSource.append(line);
1889                                                 beginningOfLineIndex = beginningOfLineIndex
1890                                                                 + line.length();
1891                                                 if ((line = reader.readLine()) != null) {
1892                                                         formattedSource
1893                                                                         .append(options.lineSeparatorSequence);
1894                                                         beginningOfLineIndex += options.lineSeparatorSequence.length;
1895                                                         dumpTab(currentLineIndentationLevel);
1896                                                 }
1897                                         }
1898                                         reader.close();
1899                                 } catch (IOException e) {
1900                                         e.printStackTrace();
1901                                 }
1902                         } else {
1903                                 updateMappedPositionsWhileSplitting(beginningOfLineIndex,
1904                                                 beginningOfLineIndex + max);
1905                                 for (int i = 0; i < max; i++) {
1906                                         char currentChar = currentString.charAt(i);
1907                                         switch (currentChar) {
1908                                         case '\r':
1909                                                 break;
1910                                         case '\n':
1911                                                 if (i != max - 1) {
1912                                                         // fix for 1FFYL5C: LFCOM:ALL - Incorrect
1913                                                         // indentation when
1914                                                         // split with a comment inside a condition
1915                                                         // a substring cannot end with a
1916                                                         // lineSeparatorSequence,
1917                                                         // except if it has been added by format() after a
1918                                                         // one-line
1919                                                         // comment
1920                                                         formattedSource
1921                                                                         .append(options.lineSeparatorSequence);
1922                                                         // 1FGDDV6: LFCOM:WIN98 - Weird splitting on message
1923                                                         // expression
1924                                                         dumpTab(depth - 1);
1925                                                 }
1926                                                 break;
1927                                         default:
1928                                                 formattedSource.append(currentChar);
1929                                         }
1930                                 }
1931                         }
1932                         // update positions inside the mappedPositions table
1933                         if (substringIndex != -1) {
1934                                 if (multipleLineCommentCounter == 0) {
1935                                         int startPosition = beginningOfLineIndex
1936                                                         + startSubstringIndexes[substringIndex];
1937                                         updateMappedPositionsWhileSplitting(startPosition,
1938                                                         startPosition + max);
1939                                 }
1940                                 // compute the splitDelta resulting with the operator and blank
1941                                 // removal
1942                                 if (substringIndex + 1 != startSubstringIndexes.length) {
1943                                         increaseSplitDelta(startSubstringIndexes[substringIndex]
1944                                                         + max - startSubstringIndexes[substringIndex + 1]);
1945                                 }
1946                         }
1947                         // dump postfix operator?
1948                         if (placeOperatorBehind) {
1949                                 if (insertSpaceBefore(operator)) {
1950                                         formattedSource.append(' ');
1951                                         if (operator != 0) {
1952                                                 increaseSplitDelta(1);
1953                                         }
1954                                 }
1955                                 formattedSource.append(operatorString);
1956                                 if (operator != 0) {
1957                                         increaseSplitDelta(operatorString.length());
1958                                 }
1959                         }
1960                         return;
1961                 }
1962                 // fix for 1FG0BA3: LFCOM:WIN98 - Weird splitting on interfaces
1963                 // extends has to stand alone on a line when currentString has been
1964                 // split.
1965                 if (options.maxLineLength != 0 && splitLine != null
1966                                 && (operator == TokenNameextends)) {
1967                         // || operator == TokenNameimplements
1968                         // || operator == TokenNamethrows)) {
1969                         formattedSource.append(options.lineSeparatorSequence);
1970                         increaseSplitDelta(options.lineSeparatorSequence.length);
1971                         dumpTab(depth + 1);
1972                 } else {
1973                         if (operator == TokenNameextends) {
1974                                 // || operator == TokenNameimplements
1975                                 // || operator == TokenNamethrows) {
1976                                 formattedSource.append(' ');
1977                                 increaseSplitDelta(1);
1978                         }
1979                 }
1980                 // perform actual splitting
1981                 String result[] = splitLine.substrings;
1982                 int[] splitOperators = splitLine.operators;
1983                 if (result[0].length() == 0) {
1984                         // when the substring 0 is null, the substring 1 is correctly
1985                         // indented.
1986                         depth--;
1987                         emptyFirstSubString = true;
1988                 }
1989                 // the operator going in front of the result[0] string is the operator
1990                 // parameter
1991                 for (int i = 0, max = result.length; i < max; i++) {
1992                         // the new depth is the current one if this is the first substring,
1993                         // the current one + 1 otherwise.
1994                         // if the substring is a comment, use the current indentation Level
1995                         // instead of the depth
1996                         // (-1 because the ouputline increases depth).
1997                         // (fix for 1FFC72R: LFCOM:ALL - Incorrect line split in presence of
1998                         // line
1999                         // comments)
2000                         String currentResult = result[i];
2001                         if (currentResult.length() != 0 || splitOperators[i] != 0) {
2002                                 int newDepth = (currentResult.startsWith("/*") //$NON-NLS-1$
2003                                 || currentResult.startsWith("//")) //$NON-NLS-1$
2004                                 ? indentationLevel - 1
2005                                                 : depth;
2006                                 outputLine(currentResult, i == 0
2007                                                 || (i == 1 && emptyFirstSubString) ? preIndented
2008                                                 : false, i == 0 ? newDepth : newDepth + 1,
2009                                                 splitOperators[i], i, splitLine.startSubstringsIndexes,
2010                                                 currentString.indexOf(currentResult));
2011                                 if (i != max - 1) {
2012                                         formattedSource.append(options.lineSeparatorSequence);
2013                                         increaseSplitDelta(options.lineSeparatorSequence.length);
2014                                 }
2015                         }
2016                 }
2017                 if (result.length == splitOperators.length - 1) {
2018                         int lastOperator = splitOperators[result.length];
2019                         String lastOperatorString = operatorString(lastOperator);
2020                         formattedSource.append(options.lineSeparatorSequence);
2021                         increaseSplitDelta(options.lineSeparatorSequence.length);
2022                         if (breakLineBeforeOperator(lastOperator)) {
2023                                 dumpTab(depth + 1);
2024                                 if (lastOperator != 0) {
2025                                         if (insertSpaceBefore(lastOperator)) {
2026                                                 formattedSource.append(' ');
2027                                                 increaseSplitDelta(1);
2028                                         }
2029                                         formattedSource.append(lastOperatorString);
2030                                         increaseSplitDelta(lastOperatorString.length());
2031                                         if (insertSpaceAfter(lastOperator)
2032                                                         && lastOperator != TokenNameimplements
2033                                                         && lastOperator != TokenNameextends) {
2034                                                 // && lastOperator != TokenNamethrows) {
2035                                                 formattedSource.append(' ');
2036                                                 increaseSplitDelta(1);
2037                                         }
2038                                 }
2039                         }
2040                 }
2041                 if (placeOperatorBehind) {
2042                         if (insertSpaceBefore(operator)) {
2043                                 formattedSource.append(' ');
2044                                 increaseSplitDelta(1);
2045                         }
2046                         formattedSource.append(operatorString);
2047                         // increaseSplitDelta(operatorString.length());
2048                 }
2049         }
2050
2051         /**
2052          * Pops the top statement of the stack if it is <code>token</code>
2053          */
2054         private int pop(int token) {
2055                 int delta = 0;
2056                 if ((constructionsCount > 0)
2057                                 && (constructions[constructionsCount - 1] == token)) {
2058                         delta--;
2059                         constructionsCount--;
2060                 }
2061                 return delta;
2062         }
2063
2064         /**
2065          * Pops the top statement of the stack if it is a <code>BLOCK</code> or a
2066          * <code>NONINDENT_BLOCK</code>.
2067          */
2068         private int popBlock() {
2069                 int delta = 0;
2070                 if ((constructionsCount > 0)
2071                                 && ((constructions[constructionsCount - 1] == BLOCK) || (constructions[constructionsCount - 1] == NONINDENT_BLOCK))) {
2072                         if (constructions[constructionsCount - 1] == BLOCK)
2073                                 delta--;
2074                         constructionsCount--;
2075                 }
2076                 return delta;
2077         }
2078
2079         /**
2080          * Pops elements until the stack is empty or the top element is
2081          * <code>token</code>.<br>
2082          * Does not remove <code>token</code> from the stack.
2083          * 
2084          * @param token
2085          *            the token to be left as the top of the stack
2086          */
2087         private int popExclusiveUntil(int token) {
2088                 int delta = 0;
2089                 int startCount = constructionsCount;
2090                 for (int i = startCount - 1; i >= 0 && constructions[i] != token; i--) {
2091                         if (constructions[i] != NONINDENT_BLOCK)
2092                                 delta--;
2093                         constructionsCount--;
2094                 }
2095                 return delta;
2096         }
2097
2098         /**
2099          * Pops elements until the stack is empty or the top element is a
2100          * <code>BLOCK</code> or a <code>NONINDENT_BLOCK</code>.<br>
2101          * Does not remove it from the stack.
2102          */
2103         private int popExclusiveUntilBlock() {
2104                 int startCount = constructionsCount;
2105                 int delta = 0;
2106                 for (int i = startCount - 1; i >= 0 && constructions[i] != BLOCK
2107                                 && constructions[i] != NONINDENT_BLOCK; i--) {
2108                         constructionsCount--;
2109                         delta--;
2110                 }
2111                 return delta;
2112         }
2113
2114         /**
2115          * Pops elements until the stack is empty or the top element is a
2116          * <code>BLOCK</code>, a <code>NONINDENT_BLOCK</code> or a
2117          * <code>CASE</code>.<br>
2118          * Does not remove it from the stack.
2119          */
2120         private int popExclusiveUntilBlockOrCase() {
2121                 int startCount = constructionsCount;
2122                 int delta = 0;
2123                 for (int i = startCount - 1; i >= 0 && constructions[i] != BLOCK
2124                                 && constructions[i] != NONINDENT_BLOCK
2125                                 && constructions[i] != TokenNamecase; i--) {
2126                         constructionsCount--;
2127                         delta--;
2128                 }
2129                 return delta;
2130         }
2131
2132         /**
2133          * Pops elements until the stack is empty or the top element is
2134          * <code>token</code>.<br>
2135          * Removes <code>token</code> from the stack too.
2136          * 
2137          * @param token
2138          *            the token to remove from the stack
2139          */
2140         private int popInclusiveUntil(int token) {
2141                 int startCount = constructionsCount;
2142                 int delta = 0;
2143                 for (int i = startCount - 1; i >= 0 && constructions[i] != token; i--) {
2144                         if (constructions[i] != NONINDENT_BLOCK)
2145                                 delta--;
2146                         constructionsCount--;
2147                 }
2148                 if (constructionsCount > 0) {
2149                         if (constructions[constructionsCount - 1] != NONINDENT_BLOCK)
2150                                 delta--;
2151                         constructionsCount--;
2152                 }
2153                 return delta;
2154         }
2155
2156         /**
2157          * Pops elements until the stack is empty or the top element is a
2158          * <code>BLOCK</code> or a <code>NONINDENT_BLOCK</code>.<br>
2159          * Does not remove it from the stack.
2160          */
2161         private int popInclusiveUntilBlock() {
2162                 int startCount = constructionsCount;
2163                 int delta = 0;
2164                 for (int i = startCount - 1; i >= 0
2165                                 && (constructions[i] != BLOCK && constructions[i] != NONINDENT_BLOCK); i--) {
2166                         delta--;
2167                         constructionsCount--;
2168                 }
2169                 if (constructionsCount > 0) {
2170                         if (constructions[constructionsCount - 1] == BLOCK)
2171                                 delta--;
2172                         constructionsCount--;
2173                 }
2174                 return delta;
2175         }
2176
2177         /**
2178          * Pushes a block in the stack. <br>
2179          * Pushes a <code>BLOCK</code> if the stack is empty or if the top element
2180          * is a <code>BLOCK</code>, pushes <code>NONINDENT_BLOCK</code>
2181          * otherwise. Creates a new bigger array if the current one is full.
2182          */
2183         private int pushBlock() {
2184                 int delta = 0;
2185                 if (constructionsCount == constructions.length)
2186                         System.arraycopy(constructions, 0,
2187                                         (constructions = new int[constructionsCount * 2]), 0,
2188                                         constructionsCount);
2189                 if ((constructionsCount == 0)
2190                                 || (constructions[constructionsCount - 1] == BLOCK)
2191                                 || (constructions[constructionsCount - 1] == NONINDENT_BLOCK)
2192                                 || (constructions[constructionsCount - 1] == TokenNamecase)) {
2193                         delta++;
2194                         constructions[constructionsCount++] = BLOCK;
2195                 } else {
2196                         constructions[constructionsCount++] = NONINDENT_BLOCK;
2197                 }
2198                 return delta;
2199         }
2200
2201         /**
2202          * Pushes <code>token</code>.<br>
2203          * Creates a new bigger array if the current one is full.
2204          */
2205         private int pushControlStatement(int token) {
2206                 if (constructionsCount == constructions.length)
2207                         System.arraycopy(constructions, 0,
2208                                         (constructions = new int[constructionsCount * 2]), 0,
2209                                         constructionsCount);
2210                 constructions[constructionsCount++] = token;
2211                 return 1;
2212         }
2213
2214         private static boolean separateFirstArgumentOn(int currentToken) {
2215                 // return (currentToken == TokenNameCOMMA || currentToken ==
2216                 // TokenNameSEMICOLON);
2217                 return currentToken != TokenNameif && currentToken != TokenNameLPAREN
2218                                 && currentToken != TokenNameNOT
2219                                 && currentToken != TokenNamewhile
2220                                 && currentToken != TokenNamefor
2221                                 && currentToken != TokenNameforeach
2222                                 && currentToken != TokenNameswitch;
2223         }
2224
2225         /**
2226          * Set the positions to map. The mapped positions should be retrieved using
2227          * the getMappedPositions() method.
2228          * 
2229          * @param positions
2230          *            int[]
2231          * @deprecated Set the positions to map using the format(String, int, int[])
2232          *             method.
2233          * 
2234          * @see #getMappedPositions()
2235          */
2236         public void setPositionsToMap(int[] positions) {
2237                 positionsToMap = positions;
2238                 lineDelta = 0;
2239                 globalDelta = 0;
2240                 mappedPositions = new int[positions.length];
2241         }
2242
2243         /**
2244          * Appends a space character to the current line buffer.
2245          */
2246         private void space() {
2247                 currentLineBuffer.append(' ');
2248                 increaseLineDelta(1);
2249         }
2250
2251         /**
2252          * Splits <code>stringToSplit</code> on the top level token <br>
2253          * If there are several identical token at the same level, the string is cut
2254          * into many pieces.
2255          * 
2256          * @return an object containing the operator and all the substrings or null
2257          *         if the string cannot be split
2258          */
2259         public SplitLine split(String stringToSplit) {
2260                 return split(stringToSplit, 0);
2261         }
2262
2263         /**
2264          * Splits <code>stringToSplit</code> on the top level token <br>
2265          * If there are several identical token at the same level, the string is cut
2266          * into many pieces.
2267          * 
2268          * @return an object containing the operator and all the substrings or null
2269          *         if the string cannot be split
2270          */
2271         public SplitLine split(String stringToSplit, int offsetInGlobalLine) {
2272                 /*
2273                  * See http://dev.eclipse.org/bugs/show_bug.cgi?id=12540 and
2274                  * http://dev.eclipse.org/bugs/show_bug.cgi?id=14387
2275                  */
2276                 if (stringToSplit.indexOf("//$NON-NLS") != -1) { //$NON-NLS-1$
2277                         return null;
2278                 }
2279                 // split doesn't work correct for PHP
2280                 return null;
2281                 // local variables
2282                 // int currentToken = 0;
2283                 // int splitTokenType = 0;
2284                 // int splitTokenDepth = Integer.MAX_VALUE;
2285                 // int splitTokenPriority = Integer.MAX_VALUE;
2286                 // int[] substringsStartPositions = new int[10];
2287                 // // contains the start position of substrings
2288                 // int[] substringsEndPositions = new int[10];
2289                 // // contains the start position of substrings
2290                 // int substringsCount = 1; // index in the substringsStartPosition
2291                 // array
2292                 // int[] splitOperators = new int[10];
2293                 // // contains the start position of substrings
2294                 // int splitOperatorsCount = 0; // index in the substringsStartPosition
2295                 // array
2296                 // int[] openParenthesisPosition = new int[10];
2297                 // int openParenthesisPositionCount = 0;
2298                 // int position = 0;
2299                 // int lastOpenParenthesisPosition = -1;
2300                 // // used to remember the position of the 1st open parenthesis
2301                 // // needed for a pattern like: A.B(C); we want formatted like A.B(
2302                 // split C);
2303                 // // setup the scanner with a new source
2304                 // int lastCommentStartPosition = -1;
2305                 // // to remember the start position of the last comment
2306                 // int firstTokenOnLine = -1;
2307                 // // to remember the first token of the line
2308                 // int previousToken = -1;
2309                 // // to remember the previous token.
2310                 // splitScanner.setSource(stringToSplit.toCharArray());
2311                 // try {
2312                 // // start the loop
2313                 // while (true) {
2314                 // // takes the next token
2315                 // try {
2316                 // if (currentToken != Scanner.TokenNameWHITESPACE)
2317                 // previousToken = currentToken;
2318                 // currentToken = splitScanner.getNextToken();
2319                 // if (Scanner.DEBUG) {
2320                 // int currentEndPosition = splitScanner.getCurrentTokenEndPosition();
2321                 // int currentStartPosition = splitScanner
2322                 // .getCurrentTokenStartPosition();
2323                 // System.out.print(currentStartPosition + "," + currentEndPosition
2324                 // + ": ");
2325                 // System.out.println(scanner.toStringAction(currentToken));
2326                 // }
2327                 // } catch (InvalidInputException e) {
2328                 // if (!handleInvalidToken(e))
2329                 // throw e;
2330                 // currentToken = 0;
2331                 // // this value is not modify when an exception is raised.
2332                 // }
2333                 // if (currentToken == TokenNameEOF)
2334                 // break;
2335                 // if (firstTokenOnLine == -1) {
2336                 // firstTokenOnLine = currentToken;
2337                 // }
2338                 // switch (currentToken) {
2339                 // case TokenNameRBRACE :
2340                 // case TokenNameRPAREN :
2341                 // if (openParenthesisPositionCount > 0) {
2342                 // if (openParenthesisPositionCount == 1
2343                 // && lastOpenParenthesisPosition < openParenthesisPosition[0]) {
2344                 // lastOpenParenthesisPosition = openParenthesisPosition[0];
2345                 // } else if ((splitTokenDepth == Integer.MAX_VALUE)
2346                 // || (splitTokenDepth > openParenthesisPositionCount &&
2347                 // openParenthesisPositionCount == 1)) {
2348                 // splitTokenType = 0;
2349                 // splitTokenDepth = openParenthesisPositionCount;
2350                 // splitTokenPriority = Integer.MAX_VALUE;
2351                 // substringsStartPositions[0] = 0;
2352                 // // better token means the whole line until now is the first
2353                 // // substring
2354                 // substringsCount = 1; // resets the count of substrings
2355                 // substringsEndPositions[0] = openParenthesisPosition[0];
2356                 // // substring ends on operator start
2357                 // position = openParenthesisPosition[0];
2358                 // // the string mustn't be cut before the closing parenthesis but
2359                 // // after the opening one.
2360                 // splitOperatorsCount = 1; // resets the count of split operators
2361                 // splitOperators[0] = 0;
2362                 // }
2363                 // openParenthesisPositionCount--;
2364                 // }
2365                 // break;
2366                 // case TokenNameLBRACE :
2367                 // case TokenNameLPAREN :
2368                 // if (openParenthesisPositionCount == openParenthesisPosition.length) {
2369                 // System
2370                 // .arraycopy(
2371                 // openParenthesisPosition,
2372                 // 0,
2373                 // (openParenthesisPosition = new int[openParenthesisPositionCount *
2374                 // 2]),
2375                 // 0, openParenthesisPositionCount);
2376                 // }
2377                 // openParenthesisPosition[openParenthesisPositionCount++] =
2378                 // splitScanner.currentPosition;
2379                 // if (currentToken == TokenNameLPAREN
2380                 // && previousToken == TokenNameRPAREN) {
2381                 // openParenthesisPosition[openParenthesisPositionCount - 1] =
2382                 // splitScanner.startPosition;
2383                 // }
2384                 // break;
2385                 // case TokenNameSEMICOLON :
2386                 // // ;
2387                 // case TokenNameCOMMA :
2388                 // // ,
2389                 // case TokenNameEQUAL :
2390                 // // =
2391                 // if (openParenthesisPositionCount < splitTokenDepth
2392                 // || (openParenthesisPositionCount == splitTokenDepth &&
2393                 // splitTokenPriority > getTokenPriority(currentToken))) {
2394                 // // the current token is better than the one we currently have
2395                 // // (in level or in priority if same level)
2396                 // // reset the substringsCount
2397                 // splitTokenDepth = openParenthesisPositionCount;
2398                 // splitTokenType = currentToken;
2399                 // splitTokenPriority = getTokenPriority(currentToken);
2400                 // substringsStartPositions[0] = 0;
2401                 // // better token means the whole line until now is the first
2402                 // // substring
2403                 // if (separateFirstArgumentOn(firstTokenOnLine)
2404                 // && openParenthesisPositionCount > 0) {
2405                 // substringsCount = 2; // resets the count of substrings
2406                 // substringsEndPositions[0] = openParenthesisPosition[splitTokenDepth -
2407                 // 1];
2408                 // substringsStartPositions[1] = openParenthesisPosition[splitTokenDepth
2409                 // - 1];
2410                 // substringsEndPositions[1] = splitScanner.startPosition;
2411                 // splitOperatorsCount = 2; // resets the count of split operators
2412                 // splitOperators[0] = 0;
2413                 // splitOperators[1] = currentToken;
2414                 // position = splitScanner.currentPosition;
2415                 // // next substring will start from operator end
2416                 // } else {
2417                 // substringsCount = 1; // resets the count of substrings
2418                 // substringsEndPositions[0] = splitScanner.startPosition;
2419                 // // substring ends on operator start
2420                 // position = splitScanner.currentPosition;
2421                 // // next substring will start from operator end
2422                 // splitOperatorsCount = 1; // resets the count of split operators
2423                 // splitOperators[0] = currentToken;
2424                 // }
2425                 // } else {
2426                 // if ((openParenthesisPositionCount == splitTokenDepth &&
2427                 // splitTokenPriority == getTokenPriority(currentToken))
2428                 // && splitTokenType != TokenNameEQUAL
2429                 // && currentToken != TokenNameEQUAL) {
2430                 // // fix for 1FG0BCN: LFCOM:WIN98 - Missing one indentation after
2431                 // // split
2432                 // // take only the 1st = into account.
2433                 // // if another token with the same priority is found,
2434                 // // push the start position of the substring and
2435                 // // push the token into the stack.
2436                 // // create a new array object if the current one is full.
2437                 // if (substringsCount == substringsStartPositions.length) {
2438                 // System
2439                 // .arraycopy(
2440                 // substringsStartPositions,
2441                 // 0,
2442                 // (substringsStartPositions = new int[substringsCount * 2]),
2443                 // 0, substringsCount);
2444                 // System.arraycopy(substringsEndPositions, 0,
2445                 // (substringsEndPositions = new int[substringsCount * 2]),
2446                 // 0, substringsCount);
2447                 // }
2448                 // if (splitOperatorsCount == splitOperators.length) {
2449                 // System.arraycopy(splitOperators, 0,
2450                 // (splitOperators = new int[splitOperatorsCount * 2]), 0,
2451                 // splitOperatorsCount);
2452                 // }
2453                 // substringsStartPositions[substringsCount] = position;
2454                 // substringsEndPositions[substringsCount++] =
2455                 // splitScanner.startPosition;
2456                 // // substring ends on operator start
2457                 // position = splitScanner.currentPosition;
2458                 // // next substring will start from operator end
2459                 // splitOperators[splitOperatorsCount++] = currentToken;
2460                 // }
2461                 // }
2462                 // break;
2463                 // case TokenNameCOLON :
2464                 // // : (15.24)
2465                 // // see 1FK7C5R, we only split on a colon, when it is associated
2466                 // // with a question-mark.
2467                 // // indeed it might appear also behind a case statement, and we do
2468                 // // not to break at this point.
2469                 // if ((splitOperatorsCount == 0)
2470                 // || splitOperators[splitOperatorsCount - 1] != TokenNameQUESTION) {
2471                 // break;
2472                 // }
2473                 // case TokenNameextends :
2474                 // case TokenNameimplements :
2475                 // //case TokenNamethrows :
2476                 // case TokenNameDOT :
2477                 // // .
2478                 // case TokenNameMULTIPLY :
2479                 // // * (15.16.1)
2480                 // case TokenNameDIVIDE :
2481                 // // / (15.16.2)
2482                 // case TokenNameREMAINDER :
2483                 // // % (15.16.3)
2484                 // case TokenNamePLUS :
2485                 // // + (15.17, 15.17.2)
2486                 // case TokenNameMINUS :
2487                 // // - (15.17.2)
2488                 // case TokenNameLEFT_SHIFT :
2489                 // // << (15.18)
2490                 // case TokenNameRIGHT_SHIFT :
2491                 // // >> (15.18)
2492                 // // case TokenNameUNSIGNED_RIGHT_SHIFT : // >>> (15.18)
2493                 // case TokenNameLESS :
2494                 // // < (15.19.1)
2495                 // case TokenNameLESS_EQUAL :
2496                 // // <= (15.19.1)
2497                 // case TokenNameGREATER :
2498                 // // > (15.19.1)
2499                 // case TokenNameGREATER_EQUAL :
2500                 // // >= (15.19.1)
2501                 // // case TokenNameinstanceof : // instanceof
2502                 // case TokenNameEQUAL_EQUAL :
2503                 // // == (15.20, 15.20.1, 15.20.2, 15.20.3)
2504                 // case TokenNameEQUAL_EQUAL_EQUAL :
2505                 // // == (15.20, 15.20.1, 15.20.2, 15.20.3)
2506                 // case TokenNameNOT_EQUAL :
2507                 // // != (15.20, 15.20.1, 15.20.2, 15.20.3)
2508                 // case TokenNameNOT_EQUAL_EQUAL :
2509                 // // != (15.20, 15.20.1, 15.20.2, 15.20.3)
2510                 // case TokenNameAND :
2511                 // // & (15.21, 15.21.1, 15.21.2)
2512                 // case TokenNameOR :
2513                 // // | (15.21, 15.21.1, 15.21.2)
2514                 // case TokenNameXOR :
2515                 // // ^ (15.21, 15.21.1, 15.21.2)
2516                 // case TokenNameAND_AND :
2517                 // // && (15.22)
2518                 // case TokenNameOR_OR :
2519                 // // || (15.23)
2520                 // case TokenNameQUESTION :
2521                 // // ? (15.24)
2522                 // case TokenNameMULTIPLY_EQUAL :
2523                 // // *= (15.25.2)
2524                 // case TokenNameDIVIDE_EQUAL :
2525                 // // /= (15.25.2)
2526                 // case TokenNameREMAINDER_EQUAL :
2527                 // // %= (15.25.2)
2528                 // case TokenNamePLUS_EQUAL :
2529                 // // += (15.25.2)
2530                 // case TokenNameMINUS_EQUAL :
2531                 // // -= (15.25.2)
2532                 // case TokenNameLEFT_SHIFT_EQUAL :
2533                 // // <<= (15.25.2)
2534                 // case TokenNameRIGHT_SHIFT_EQUAL :
2535                 // // >>= (15.25.2)
2536                 // // case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>= (15.25.2)
2537                 // case TokenNameAND_EQUAL :
2538                 // // &= (15.25.2)
2539                 // case TokenNameXOR_EQUAL :
2540                 // // ^= (15.25.2)
2541                 // case TokenNameOR_EQUAL :
2542                 // // |= (15.25.2)
2543                 // if ((openParenthesisPositionCount < splitTokenDepth ||
2544                 // (openParenthesisPositionCount == splitTokenDepth &&
2545                 // splitTokenPriority
2546                 // > getTokenPriority(currentToken)))
2547                 // && !((currentToken == TokenNamePLUS || currentToken ==
2548                 // TokenNameMINUS) && (previousToken == TokenNameLBRACE
2549                 // || previousToken == TokenNameLBRACKET || splitScanner.startPosition
2550                 // == 0))) {
2551                 // // the current token is better than the one we currently have
2552                 // // (in level or in priority if same level)
2553                 // // reset the substringsCount
2554                 // splitTokenDepth = openParenthesisPositionCount;
2555                 // splitTokenType = currentToken;
2556                 // splitTokenPriority = getTokenPriority(currentToken);
2557                 // substringsStartPositions[0] = 0;
2558                 // // better token means the whole line until now is the first
2559                 // // substring
2560                 // if (separateFirstArgumentOn(firstTokenOnLine)
2561                 // && openParenthesisPositionCount > 0) {
2562                 // substringsCount = 2; // resets the count of substrings
2563                 // substringsEndPositions[0] = openParenthesisPosition[splitTokenDepth -
2564                 // 1];
2565                 // substringsStartPositions[1] = openParenthesisPosition[splitTokenDepth
2566                 // - 1];
2567                 // substringsEndPositions[1] = splitScanner.startPosition;
2568                 // splitOperatorsCount = 3; // resets the count of split operators
2569                 // splitOperators[0] = 0;
2570                 // splitOperators[1] = 0;
2571                 // splitOperators[2] = currentToken;
2572                 // position = splitScanner.currentPosition;
2573                 // // next substring will start from operator end
2574                 // } else {
2575                 // substringsCount = 1; // resets the count of substrings
2576                 // substringsEndPositions[0] = splitScanner.startPosition;
2577                 // // substring ends on operator start
2578                 // position = splitScanner.currentPosition;
2579                 // // next substring will start from operator end
2580                 // splitOperatorsCount = 2; // resets the count of split operators
2581                 // splitOperators[0] = 0;
2582                 // // nothing for first operand since operator will be inserted in
2583                 // // front of the second operand
2584                 // splitOperators[1] = currentToken;
2585                 // }
2586                 // } else {
2587                 // if (openParenthesisPositionCount == splitTokenDepth
2588                 // && splitTokenPriority == getTokenPriority(currentToken)) {
2589                 // // if another token with the same priority is found,
2590                 // // push the start position of the substring and
2591                 // // push the token into the stack.
2592                 // // create a new array object if the current one is full.
2593                 // if (substringsCount == substringsStartPositions.length) {
2594                 // System
2595                 // .arraycopy(
2596                 // substringsStartPositions,
2597                 // 0,
2598                 // (substringsStartPositions = new int[substringsCount * 2]),
2599                 // 0, substringsCount);
2600                 // System.arraycopy(substringsEndPositions, 0,
2601                 // (substringsEndPositions = new int[substringsCount * 2]),
2602                 // 0, substringsCount);
2603                 // }
2604                 // if (splitOperatorsCount == splitOperators.length) {
2605                 // System.arraycopy(splitOperators, 0,
2606                 // (splitOperators = new int[splitOperatorsCount * 2]), 0,
2607                 // splitOperatorsCount);
2608                 // }
2609                 // substringsStartPositions[substringsCount] = position;
2610                 // substringsEndPositions[substringsCount++] =
2611                 // splitScanner.startPosition;
2612                 // // substring ends on operator start
2613                 // position = splitScanner.currentPosition;
2614                 // // next substring will start from operator end
2615                 // splitOperators[splitOperatorsCount++] = currentToken;
2616                 // }
2617                 // }
2618                 // default :
2619                 // break;
2620                 // }
2621                 // if (isComment(currentToken)) {
2622                 // lastCommentStartPosition = splitScanner.startPosition;
2623                 // } else {
2624                 // lastCommentStartPosition = -1;
2625                 // }
2626                 // }
2627                 // } catch (InvalidInputException e) {
2628                 // return null;
2629                 // }
2630                 // // if the string cannot be split, return null.
2631                 // if (splitOperatorsCount == 0)
2632                 // return null;
2633                 // // ## SPECIAL CASES BEGIN
2634                 // if (((splitOperatorsCount == 2 && splitOperators[1] == TokenNameDOT
2635                 // && splitTokenDepth == 0 && lastOpenParenthesisPosition > -1)
2636                 // || (splitOperatorsCount > 2 && splitOperators[1] == TokenNameDOT
2637                 // && splitTokenDepth == 0 && lastOpenParenthesisPosition > -1 &&
2638                 // lastOpenParenthesisPosition <= options.maxLineLength) ||
2639                 // (separateFirstArgumentOn(firstTokenOnLine)
2640                 // && splitTokenDepth > 0 && lastOpenParenthesisPosition > -1))
2641                 // && (lastOpenParenthesisPosition < splitScanner.source.length &&
2642                 // splitScanner.source[lastOpenParenthesisPosition] != ')')) {
2643                 // // fix for 1FH4J2H: LFCOM:WINNT - Formatter - Empty parenthesis
2644                 // should
2645                 // // not be broken on two lines
2646                 // // only one split on a top level .
2647                 // // or more than one split on . and substring before open parenthesis
2648                 // fits
2649                 // // one line.
2650                 // // or split inside parenthesis and first token is not a for/while/if
2651                 // SplitLine sl = split(
2652                 // stringToSplit.substring(lastOpenParenthesisPosition),
2653                 // lastOpenParenthesisPosition);
2654                 // if (sl == null || sl.operators[0] != TokenNameCOMMA) {
2655                 // // trim() is used to remove the extra blanks at the end of the
2656                 // // substring. See PR 1FGYPI1
2657                 // return new SplitLine(new int[]{0, 0}, new String[]{
2658                 // stringToSplit.substring(0, lastOpenParenthesisPosition).trim(),
2659                 // stringToSplit.substring(lastOpenParenthesisPosition)}, new int[]{
2660                 // offsetInGlobalLine,
2661                 // lastOpenParenthesisPosition + offsetInGlobalLine});
2662                 // } else {
2663                 // // right substring can be split and is split on comma
2664                 // // copy substrings and operators
2665                 // // except if the 1st string is empty.
2666                 // int startIndex = (sl.substrings[0].length() == 0) ? 1 : 0;
2667                 // int subStringsLength = sl.substrings.length + 1 - startIndex;
2668                 // String[] result = new String[subStringsLength];
2669                 // int[] startIndexes = new int[subStringsLength];
2670                 // int operatorsLength = sl.operators.length + 1 - startIndex;
2671                 // int[] operators = new int[operatorsLength];
2672                 // result[0] = stringToSplit.substring(0, lastOpenParenthesisPosition);
2673                 // operators[0] = 0;
2674                 // System.arraycopy(sl.startSubstringsIndexes, startIndex, startIndexes,
2675                 // 1, subStringsLength - 1);
2676                 // for (int i = subStringsLength - 1; i >= 0; i--) {
2677                 // startIndexes[i] += offsetInGlobalLine;
2678                 // }
2679                 // System.arraycopy(sl.substrings, startIndex, result, 1,
2680                 // subStringsLength - 1);
2681                 // System.arraycopy(sl.operators, startIndex, operators, 1,
2682                 // operatorsLength - 1);
2683                 // return new SplitLine(operators, result, startIndexes);
2684                 // }
2685                 // }
2686                 // // if the last token is a comment and the substring before the
2687                 // comment fits
2688                 // // on a line,
2689                 // // split before the comment and return the result.
2690                 // if (lastCommentStartPosition > -1
2691                 // && lastCommentStartPosition < options.maxLineLength
2692                 // && splitTokenPriority > 50) {
2693                 // int end = lastCommentStartPosition;
2694                 // int start = lastCommentStartPosition;
2695                 // if (stringToSplit.charAt(end - 1) == ' ') {
2696                 // end--;
2697                 // }
2698                 // if (start != end && stringToSplit.charAt(start) == ' ') {
2699                 // start++;
2700                 // }
2701                 // return new SplitLine(new int[]{0, 0}, new String[]{
2702                 // stringToSplit.substring(0, end), stringToSplit.substring(start)},
2703                 // new int[]{0, start});
2704                 // }
2705                 // if (position != stringToSplit.length()) {
2706                 // if (substringsCount == substringsStartPositions.length) {
2707                 // System.arraycopy(substringsStartPositions, 0,
2708                 // (substringsStartPositions = new int[substringsCount * 2]), 0,
2709                 // substringsCount);
2710                 // System.arraycopy(substringsEndPositions, 0,
2711                 // (substringsEndPositions = new int[substringsCount * 2]), 0,
2712                 // substringsCount);
2713                 // }
2714                 // // avoid empty extra substring, e.g. line terminated with a
2715                 // semi-colon
2716                 // substringsStartPositions[substringsCount] = position;
2717                 // substringsEndPositions[substringsCount++] = stringToSplit.length();
2718                 // }
2719                 // if (splitOperatorsCount == splitOperators.length) {
2720                 // System.arraycopy(splitOperators, 0,
2721                 // (splitOperators = new int[splitOperatorsCount * 2]), 0,
2722                 // splitOperatorsCount);
2723                 // }
2724                 // splitOperators[splitOperatorsCount] = 0;
2725                 // // the last element of the stack is the position of the end of
2726                 // // StringToSPlit
2727                 // // +1 because the substring method excludes the last character
2728                 // String[] result = new String[substringsCount];
2729                 // for (int i = 0; i < substringsCount; i++) {
2730                 // int start = substringsStartPositions[i];
2731                 // int end = substringsEndPositions[i];
2732                 // if (stringToSplit.charAt(start) == ' ') {
2733                 // start++;
2734                 // substringsStartPositions[i]++;
2735                 // }
2736                 // if (end != start && stringToSplit.charAt(end - 1) == ' ') {
2737                 // end--;
2738                 // }
2739                 // result[i] = stringToSplit.substring(start, end);
2740                 // substringsStartPositions[i] += offsetInGlobalLine;
2741                 // }
2742                 // if (splitOperatorsCount > substringsCount) {
2743                 // System.arraycopy(substringsStartPositions, 0,
2744                 // (substringsStartPositions = new int[splitOperatorsCount]), 0,
2745                 // substringsCount);
2746                 // System.arraycopy(substringsEndPositions, 0,
2747                 // (substringsEndPositions = new int[splitOperatorsCount]), 0,
2748                 // substringsCount);
2749                 // for (int i = substringsCount; i < splitOperatorsCount; i++) {
2750                 // substringsStartPositions[i] = position;
2751                 // substringsEndPositions[i] = position;
2752                 // }
2753                 // System.arraycopy(splitOperators, 0,
2754                 // (splitOperators = new int[splitOperatorsCount]), 0,
2755                 // splitOperatorsCount);
2756                 // } else {
2757                 // System.arraycopy(substringsStartPositions, 0,
2758                 // (substringsStartPositions = new int[substringsCount]), 0,
2759                 // substringsCount);
2760                 // System.arraycopy(substringsEndPositions, 0,
2761                 // (substringsEndPositions = new int[substringsCount]), 0,
2762                 // substringsCount);
2763                 // System.arraycopy(splitOperators, 0,
2764                 // (splitOperators = new int[substringsCount]), 0, substringsCount);
2765                 // }
2766                 // SplitLine splitLine = new SplitLine(splitOperators, result,
2767                 // substringsStartPositions);
2768                 // return splitLine;
2769         }
2770
2771         private void updateMappedPositions(int startPosition) {
2772                 if (positionsToMap == null) {
2773                         return;
2774                 }
2775                 char[] source = scanner.source;
2776                 int sourceLength = source.length;
2777                 while (indexToMap < positionsToMap.length
2778                                 && positionsToMap[indexToMap] <= startPosition) {
2779                         int posToMap = positionsToMap[indexToMap];
2780                         if (posToMap < 0 || posToMap >= sourceLength) {
2781                                 // protection against out of bounds position
2782                                 if (posToMap == sourceLength) {
2783                                         mappedPositions[indexToMap] = formattedSource.length();
2784                                 }
2785                                 indexToMap = positionsToMap.length; // no more mapping
2786                                 return;
2787                         }
2788                         if (CharOperation.isWhitespace(source[posToMap])) {
2789                                 mappedPositions[indexToMap] = startPosition + globalDelta
2790                                                 + lineDelta;
2791                         } else {
2792                                 if (posToMap == sourceLength - 1) {
2793                                         mappedPositions[indexToMap] = startPosition + globalDelta
2794                                                         + lineDelta;
2795                                 } else {
2796                                         mappedPositions[indexToMap] = posToMap + globalDelta
2797                                                         + lineDelta;
2798                                 }
2799                         }
2800                         indexToMap++;
2801                 }
2802         }
2803
2804         private void updateMappedPositionsWhileSplitting(int startPosition,
2805                         int endPosition) {
2806                 if (mappedPositions == null || mappedPositions.length == indexInMap)
2807                         return;
2808                 while (indexInMap < mappedPositions.length
2809                                 && startPosition <= mappedPositions[indexInMap]
2810                                 && mappedPositions[indexInMap] < endPosition
2811                                 && indexInMap < indexToMap) {
2812                         mappedPositions[indexInMap] += splitDelta;
2813                         indexInMap++;
2814                 }
2815         }
2816
2817         private int getLength(String s, int tabDepth) {
2818                 int length = 0;
2819                 for (int i = 0; i < tabDepth; i++) {
2820                         length += options.tabSize;
2821                 }
2822                 for (int i = 0, max = s.length(); i < max; i++) {
2823                         char currentChar = s.charAt(i);
2824                         switch (currentChar) {
2825                         case '\t':
2826                                 length += options.tabSize;
2827                                 break;
2828                         default:
2829                                 length++;
2830                         }
2831                 }
2832                 return length;
2833         }
2834
2835         /**
2836          * Sets the initial indentation level
2837          * 
2838          * @param indentationLevel
2839          *            new indentation level
2840          * 
2841          * @deprecated
2842          */
2843         public void setInitialIndentationLevel(int newIndentationLevel) {
2844                 this.initialIndentationLevel = currentLineIndentationLevel = indentationLevel = newIndentationLevel;
2845         }
2846
2847 }