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