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