Set version 1.1.9
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / ui / text / JavaIndenter.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2004 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.ui.text;
12
13 import net.sourceforge.phpdt.core.JavaCore;
14 import net.sourceforge.phpdt.core.formatter.DefaultCodeFormatterConstants;
15 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
16
17 import org.eclipse.core.runtime.Plugin;
18 import org.eclipse.jface.text.Assert;
19 import org.eclipse.jface.text.BadLocationException;
20 import org.eclipse.jface.text.IDocument;
21 import org.eclipse.jface.text.IRegion;
22 import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
23
24
25 /**
26  * Uses the {@link net.sourceforge.phpdt.internal.ui.text.JavaHeuristicScanner}to
27  * get the indentation level for a certain position in a document.
28  * 
29  * <p>
30  * An instance holds some internal position in the document and is therefore
31  * not threadsafe.
32  * </p>
33  * 
34  * @since 3.0
35  */
36 public class JavaIndenter {
37
38         /** The document being scanned. */
39         private IDocument fDocument;
40         /** The indentation accumulated by <code>findPreviousIndenationUnit</code>. */
41         private int fIndent;
42         /**
43          * The absolute (character-counted) indentation offset for special cases
44          * (method defs, array initializers)
45          */
46         private int fAlign;
47         /** The stateful scanposition for the indentation methods. */
48         private int fPosition;
49         /** The previous position. */
50         private int fPreviousPos;
51         /** The most recent token. */
52         private int fToken;
53         /** The line of <code>fPosition</code>. */
54         private int fLine;
55         /**
56          * The scanner we will use to scan the document. It has to be installed
57          * on the same document as the one we get.
58          */
59         private JavaHeuristicScanner fScanner;
60
61         /**
62          * Creates a new instance.
63          * 
64          * @param document the document to scan
65          * @param scanner the {@link JavaHeuristicScanner} to be used for scanning
66          * the document. It must be installed on the same <code>IDocument</code>.
67          */
68         public JavaIndenter(IDocument document, JavaHeuristicScanner scanner) {
69                 Assert.isNotNull(document);
70                 Assert.isNotNull(scanner);
71                 fDocument= document;
72                 fScanner= scanner;
73         }
74
75         /**
76          * Computes the indentation at the reference point of <code>position</code>.
77          * 
78          * @param offset the offset in the document
79          * @return a String which reflects the indentation at the line in which the
80          *         reference position to <code>offset</code> resides, or <code>null</code>
81          *         if it cannot be determined
82          */
83         public StringBuffer getReferenceIndentation(int offset) {
84                 return getReferenceIndentation(offset, false);
85         }
86
87         /**
88          * Computes the indentation at the reference point of <code>position</code>.
89          * 
90          * @param offset the offset in the document
91          * @param assumeOpeningBrace <code>true</code> if an opening brace should be assumed
92          * @return a String which reflects the indentation at the line in which the
93          *         reference position to <code>offset</code> resides, or <code>null</code>
94          *         if it cannot be determined
95          */
96         private StringBuffer getReferenceIndentation(int offset, boolean assumeOpeningBrace) {
97
98                 int unit;
99                 if (assumeOpeningBrace)
100                         unit= findReferencePosition(offset, Symbols.TokenLBRACE);
101                 else
102                         unit= findReferencePosition(offset, peekChar(offset));
103
104                 // if we were unable to find anything, return null
105                 if (unit == JavaHeuristicScanner.NOT_FOUND)
106                         return null;
107
108                 return getLeadingWhitespace(unit);
109
110         }
111
112         /**
113          * Computes the indentation at <code>offset</code>.
114          * 
115          * @param offset the offset in the document
116          * @return a String which reflects the correct indentation for the line in
117          *         which offset resides, or <code>null</code> if it cannot be
118          *         determined
119          */
120         public StringBuffer computeIndentation(int offset) {
121                 return computeIndentation(offset, false);
122         }
123
124         /**
125          * Computes the indentation at <code>offset</code>.
126          * 
127          * @param offset the offset in the document
128          * @param assumeOpeningBrace <code>true</code> if an opening brace should be assumed
129          * @return a String which reflects the correct indentation for the line in
130          *         which offset resides, or <code>null</code> if it cannot be
131          *         determined
132          */
133         public StringBuffer computeIndentation(int offset, boolean assumeOpeningBrace) {
134
135                 StringBuffer indent= getReferenceIndentation(offset, assumeOpeningBrace);
136
137                 // handle special alignment
138                 if (fAlign != JavaHeuristicScanner.NOT_FOUND) {
139                         try {
140                                 // a special case has been detected.
141                                 IRegion line= fDocument.getLineInformationOfOffset(fAlign);
142                                 int lineOffset= line.getOffset();
143                                 return createIndent(lineOffset, fAlign);
144                         } catch (BadLocationException e) {
145                                 return null;
146                         }
147                 }
148
149                 if (indent == null)
150                         return null;
151
152                 // add additional indent
153                 indent.append(createIndent(fIndent));
154                 if (fIndent < 0)
155                         unindent(indent);
156
157                 return indent;
158         }
159
160         /**
161          * Returns the indentation of the line at <code>offset</code> as a
162          * <code>StringBuffer</code>. If the offset is not valid, the empty string
163          * is returned.
164          * 
165          * @param offset the offset in the document
166          * @return the indentation (leading whitespace) of the line in which
167          *                 <code>offset</code> is located
168          */
169         private StringBuffer getLeadingWhitespace(int offset) {
170                 StringBuffer indent= new StringBuffer();
171                 try {
172                         IRegion line= fDocument.getLineInformationOfOffset(offset);
173                         int lineOffset= line.getOffset();
174                         int nonWS= fScanner.findNonWhitespaceForwardInAnyPartition(lineOffset, lineOffset + line.getLength());
175                         indent.append(fDocument.get(lineOffset, nonWS - lineOffset));
176                         return indent;
177                 } catch (BadLocationException e) {
178                         return indent;
179                 }
180         }
181
182         /**
183          * Reduces indentation in <code>indent</code> by one indentation unit.
184          * 
185          * @param indent the indentation to be modified
186          */
187         private void unindent(StringBuffer indent) {
188                 CharSequence oneIndent= createIndent();
189                 int i= indent.lastIndexOf(oneIndent.toString()); //$NON-NLS-1$
190                 if (i != -1) {
191                         indent.delete(i, i + oneIndent.length());
192                 }
193         }
194
195         /**
196          * Creates an indentation string of the length indent - start + 1,
197          * consisting of the content in <code>fDocument</code> in the range
198          * [start, indent), with every character replaced by a space except for
199          * tabs, which are kept as such.
200          * 
201          * <p>Every run of the number of spaces that make up a tab are replaced
202          * by a tab character.</p>
203          * 
204          * @return the indentation corresponding to the document content specified
205          *         by <code>start</code> and <code>indent</code>
206          */
207         private StringBuffer createIndent(int start, int indent) {
208                 final int tabLen= prefTabLength();
209                 StringBuffer ret= new StringBuffer();
210                 try {
211                         int spaces= 0;
212                         while (start < indent) {
213
214                                 char ch= fDocument.getChar(start);
215                                 if (ch == '\t') {
216                                         ret.append('\t');
217                                         spaces= 0;
218                                 } else if (tabLen == -1){
219                                         ret.append(' ');
220                                 } else {
221                                         spaces++;
222                                         if (spaces == tabLen) {
223                                                 ret.append('\t');
224                                                 spaces= 0;
225                                         }
226                                 }
227
228                                 start++;
229                         }
230                         // remainder
231                         if (spaces == tabLen)
232                                 ret.append('\t');
233                         else
234                                 while (spaces-- > 0)
235                                         ret.append(' ');
236
237                 } catch (BadLocationException e) {
238                 }
239
240                 return ret;
241         }
242
243         /**
244          * Creates a string that represents the given number of indents (can be
245          * spaces or tabs..)
246          * 
247          * @param indent the requested indentation level.
248          * 
249          * @return the indentation specified by <code>indent</code>
250          */
251         public StringBuffer createIndent(int indent) {
252                 StringBuffer oneIndent= createIndent();
253
254                 StringBuffer ret= new StringBuffer();
255                 while (indent-- > 0)
256                         ret.append(oneIndent);
257
258                 return ret;
259         }
260
261         /**
262          * Creates a string that represents one indent (can be
263          * spaces or tabs..)
264          * 
265          * @return one indentation
266          */
267         private StringBuffer createIndent() {
268                 // get a sensible default when running without the infrastructure for testing
269                 StringBuffer oneIndent= new StringBuffer();
270 //              JavaCore plugin= JavaCore.getJavaCore();
271                 PHPeclipsePlugin plugin = PHPeclipsePlugin.getDefault();
272                 if (plugin == null) {
273                         oneIndent.append('\t');
274                 } else {
275                         if (JavaCore.SPACE.equals(JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR))) {
276                                 int tabLen= Integer.parseInt(JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE));
277                                 for (int i= 0; i < tabLen; i++)
278                                         oneIndent.append(' ');
279                         } else if (JavaCore.TAB.equals(JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR)))
280                                 oneIndent.append('\t');
281                         else
282                                 oneIndent.append('\t'); // default
283                 }
284                 return oneIndent;
285         }
286
287         /**
288          * Returns the reference position regarding to indentation for <code>offset</code>,
289          * or <code>NOT_FOUND</code>. This method calls
290          * {@link #findReferencePosition(int, int) findReferencePosition(offset, nextChar)} where
291          * <code>nextChar</code> is the next character after <code>offset</code>.
292          * 
293          * @param offset the offset for which the reference is computed
294          * @return the reference statement relative to which <code>offset</code>
295          *         should be indented, or {@link JavaHeuristicScanner#NOT_FOUND}
296          */
297         public int findReferencePosition(int offset) {
298                 return findReferencePosition(offset, peekChar(offset));
299         }
300
301         /**
302          * Peeks the next char in the document that comes after <code>offset</code>
303          * on the same line as <code>offset</code>.
304          * 
305          * @param offset the offset into document
306          * @return the token symbol of the next element, or TokenEOF if there is none
307          */
308         private int peekChar(int offset) {
309                 if (offset < fDocument.getLength()) {
310                         try {
311                                 IRegion line= fDocument.getLineInformationOfOffset(offset);
312                                 int lineOffset= line.getOffset();
313                                 int next= fScanner.nextToken(offset, lineOffset + line.getLength());
314                                 return next;
315                         } catch (BadLocationException e) {
316                         }
317                 }
318                 return Symbols.TokenEOF;
319         }
320
321         /**
322          * Returns the reference position regarding to indentation for <code>position</code>,
323          * or <code>NOT_FOUND</code>.
324          * 
325          * <p>If <code>peekNextChar</code> is <code>true</code>, the next token after
326          * <code>offset</code> is read and taken into account when computing the
327          * indentation. Currently, if the next token is the first token on the line
328          * (i.e. only preceded by whitespace), the following tokens are specially
329          * handled:
330          * <ul>
331          *      <li><code>switch</code> labels are indented relative to the switch block</li>
332          *      <li>opening curly braces are aligned correctly with the introducing code</li>
333          *      <li>closing curly braces are aligned properly with the introducing code of
334          *              the matching opening brace</li>
335          *      <li>closing parenthesis' are aligned with their opening peer</li>
336          *      <li>the <code>else</code> keyword is aligned with its <code>if</code>, anything
337          *              else is aligned normally (i.e. with the base of any introducing statements).</li>
338          *  <li>if there is no token on the same line after <code>offset</code>, the indentation
339          *              is the same as for an <code>else</code> keyword</li>
340          * </ul>
341          * 
342          * @param offset the offset for which the reference is computed
343          * @param nextToken the next token to assume in the document
344          * @return the reference statement relative to which <code>offset</code>
345          *         should be indented, or {@link JavaHeuristicScanner#NOT_FOUND}
346          */
347         public int findReferencePosition(int offset, int nextToken) {
348                 boolean danglingElse= false;
349                 boolean unindent= false;
350                 boolean indent= false;
351                 boolean matchBrace= false;
352                 boolean matchParen= false;
353                 boolean matchCase= false;
354
355                 // account for unindenation characters already typed in, but after position
356                 // if they are on a line by themselves, the indentation gets adjusted
357                 // accordingly
358                 //
359                 // also account for a dangling else
360                 if (offset < fDocument.getLength()) {
361                         try {
362                                 IRegion line= fDocument.getLineInformationOfOffset(offset);
363                                 int lineOffset= line.getOffset();
364                                 int prevPos= Math.max(offset - 1, 0);
365                                 boolean isFirstTokenOnLine= fDocument.get(lineOffset, prevPos + 1 - lineOffset).trim().length() == 0;
366                                 int prevToken= fScanner.previousToken(prevPos, JavaHeuristicScanner.UNBOUND);
367                                 boolean bracelessBlockStart= fScanner.isBracelessBlockStart(prevPos, JavaHeuristicScanner.UNBOUND);
368
369                                 switch (nextToken) {
370                                         case Symbols.TokenEOF:
371                                         case Symbols.TokenELSE:
372                                                 danglingElse= true;
373                                                 break;
374                                         case Symbols.TokenCASE:
375                                         case Symbols.TokenDEFAULT:
376                                                 if (isFirstTokenOnLine)
377                                                         matchCase= true;
378                                                 break;
379                                         case Symbols.TokenLBRACE: // for opening-brace-on-new-line style
380 //                                              if (bracelessBlockStart && !prefIndentBracesForBlocks())
381 //                                                      unindent= true;
382 //                                              else if ((prevToken == Symbols.TokenCOLON || prevToken == Symbols.TokenEQUAL || prevToken == Symbols.TokenRBRACKET) && !prefIndentBracesForArrays())
383 //                                                      unindent= true;
384 //                                              else if (!bracelessBlockStart && prefIndentBracesForMethods())
385 //                                                      indent= true;
386 //                                              break;
387                                                 if (bracelessBlockStart )
388                                                         unindent= true;
389                                                 else if ((prevToken == Symbols.TokenCOLON || prevToken == Symbols.TokenEQUAL || prevToken == Symbols.TokenRBRACKET) )
390                                                         unindent= true;
391                                                 else if (!bracelessBlockStart)
392                                                         indent= true;
393                                                 break;
394                                         case Symbols.TokenRBRACE: // closing braces get unindented
395                                                 if (isFirstTokenOnLine)
396                                                         matchBrace= true;
397                                                 break;
398                                         case Symbols.TokenRPAREN:
399                                                 if (isFirstTokenOnLine)
400                                                         matchParen= true;
401                                                 break;
402                                         }
403                         } catch (BadLocationException e) {
404                         }
405                 } else {
406                         // assume an else could come if we are at the end of file
407                         danglingElse= true;
408                 }
409
410                 int ref= findReferencePosition(offset, danglingElse, matchBrace, matchParen, matchCase);
411                 if (unindent)
412                         fIndent--;
413                 if (indent)
414                         fIndent++;
415                 return ref;
416         }
417
418         /**
419          * Returns the reference position regarding to indentation for <code>position</code>,
420          * or <code>NOT_FOUND</code>.<code>fIndent</code> will contain the
421          * relative indentation (in indentation units, not characters) after the
422          * call. If there is a special alignment (e.g. for a method declaration
423          * where parameters should be aligned), <code>fAlign</code> will contain
424          * the absolute position of the alignment reference in <code>fDocument</code>,
425          * otherwise <code>fAlign</code> is set to <code>JavaHeuristicScanner.NOT_FOUND</code>.
426          * 
427          * @param offset the offset for which the reference is computed
428          * @param danglingElse whether a dangling else should be assumed at <code>position</code>
429          * @param matchBrace whether the position of the matching brace should be
430          *            returned instead of doing code analysis
431          * @param matchParen whether the position of the matching parenthesis
432          *            should be returned instead of doing code analysis
433          * @param matchCase whether the position of a switch statement reference
434          *            should be returned (either an earlier case statement or the
435          *            switch block brace)
436          * @return the reference statement relative to which <code>position</code>
437          *         should be indented, or {@link JavaHeuristicScanner#NOT_FOUND}
438          */
439         public int findReferencePosition(int offset, boolean danglingElse, boolean matchBrace, boolean matchParen, boolean matchCase) {
440                 fIndent= 0; // the indentation modification
441                 fAlign= JavaHeuristicScanner.NOT_FOUND;
442                 fPosition= offset;
443
444                 // forward cases
445                 // an unindentation happens sometimes if the next token is special, namely on braces, parens and case labels
446                 // align braces, but handle the case where we align with the method declaration start instead of
447                 // the opening brace.
448 //              if (matchBrace) {
449 //                      if (skipScope(Symbols.TokenLBRACE, Symbols.TokenRBRACE)) {
450 //                              try {
451 //                                      // align with the opening brace that is on a line by its own
452 //                                      int lineOffset= fDocument.getLineOffset(fLine);
453 //                                      if (lineOffset <= fPosition && fDocument.get(lineOffset, fPosition - lineOffset).trim().length() == 0)
454 //                                              return fPosition;
455 //                              } catch (BadLocationException e) {
456 //                                      // concurrent modification - walk default path
457 //                              }
458 //                              // if the opening brace is not on the start of the line, skip to the start
459 //                              int pos= skipToStatementStart(true, true);
460 //                              fIndent= 0; // indent is aligned with reference position
461 //                              return pos;
462 //                      } else {
463 //                              // if we can't find the matching brace, the heuristic is to unindent
464 //                              // by one against the normal position
465 //                              int pos= findReferencePosition(offset, danglingElse, false, matchParen, matchCase);
466 //                              fIndent--;
467 //                              return pos;
468 //                      }
469 //              }
470
471                 // align parenthesis'
472                 if (matchParen) {
473                         if (skipScope(Symbols.TokenLPAREN, Symbols.TokenRPAREN))
474                                 return fPosition;
475                         else {
476                                 // if we can't find the matching paren, the heuristic is to unindent
477                                 // by one against the normal position
478                                 int pos= findReferencePosition(offset, danglingElse, matchBrace, false, matchCase);
479                                 fIndent--;
480                                 return pos;
481                         }
482                 }
483
484                 // the only reliable way to get case labels aligned (due to many different styles of using braces in a block)
485                 // is to go for another case statement, or the scope opening brace
486 //              if (matchCase) {
487 //                      return matchCaseAlignment();
488 //              }
489
490                 nextToken();
491                 switch (fToken) {
492                         case Symbols.TokenRBRACE:
493                                 // skip the block and fall through
494                                 // if we can't complete the scope, reset the scan position
495                                 int pos= fPosition;
496                                 if (!skipScope())
497                                         fPosition= pos;
498                         case Symbols.TokenSEMICOLON:
499                                 // this is the 90% case: after a statement block
500                                 // the end of the previous statement / block previous.end
501                                 // search to the end of the statement / block before the previous; the token just after that is previous.start
502                                 return skipToStatementStart(danglingElse, false);
503
504                         // scope introduction: special treat who special is
505                         case Symbols.TokenLPAREN:
506                         case Symbols.TokenLBRACE:
507                         case Symbols.TokenLBRACKET:
508                                 return handleScopeIntroduction(offset + 1);
509
510                         case Symbols.TokenEOF:
511                                 // trap when hitting start of document
512                                 return 0;
513
514                         case Symbols.TokenEQUAL:
515                                 // indent assignments
516                                 fIndent= prefAssignmentIndent();
517                                 return fPosition;
518
519                         case Symbols.TokenCOLON:
520                                 // TODO handle ternary deep indentation
521                                 fIndent= prefCaseBlockIndent();
522                                 return fPosition;
523
524                         case Symbols.TokenQUESTIONMARK:
525                                 if (prefTernaryDeepAlign()) {
526                                         setFirstElementAlignment(fPosition, offset + 1);
527                                         return fPosition;
528                                 } else {
529                                         fIndent= prefTernaryIndent();
530                                         return fPosition;
531                                 }
532
533                         // indentation for blockless introducers:
534                         case Symbols.TokenDO:
535                         case Symbols.TokenWHILE:
536                         case Symbols.TokenELSE:
537                                 fIndent= prefSimpleIndent();
538                                 return fPosition;
539                         case Symbols.TokenRPAREN:
540                                 int line= fLine;
541                                 if (skipScope(Symbols.TokenLPAREN, Symbols.TokenRPAREN)) {
542                                         int scope= fPosition;
543                                         nextToken();
544                                         if (fToken == Symbols.TokenIF || fToken == Symbols.TokenWHILE || fToken == Symbols.TokenFOR) {
545                                                 fIndent= prefSimpleIndent();
546                                                 return fPosition;
547                                         }
548                                         fPosition= scope;
549                                         if (looksLikeMethodDecl()) {
550                                                 return skipToStatementStart(danglingElse, false);
551                                         }
552                                 }
553                                 // restore
554                                 fPosition= offset;
555                                 fLine= line;
556                                 // else: fall through to default
557
558                         case Symbols.TokenCOMMA:
559                                 // inside a list of some type
560                                 // easy if there is already a list item before with its own indentation - we just align
561                                 // if not: take the start of the list ( LPAREN, LBRACE, LBRACKET ) and either align or
562                                 // indent by list-indent
563                         default:
564                                 // inside whatever we don't know about: similar to the list case:
565                                 // if we are inside a continued expression, then either align with a previous line that has indentation
566                                 // or indent from the expression start line (either a scope introducer or the start of the expr).
567                                 return skipToPreviousListItemOrListStart();
568
569                 }
570         }
571
572         /**
573          * Skips to the start of a statement that ends at the current position.
574          * 
575          * @param danglingElse whether to indent aligned with the last <code>if</code>
576          * @param isInBlock whether the current position is inside a block, which limits the search scope to the next scope introducer
577          * @return the reference offset of the start of the statement 
578          */
579         private int skipToStatementStart(boolean danglingElse, boolean isInBlock) {
580                 while (true) {
581                         nextToken();
582
583                         if (isInBlock) {
584                                 switch (fToken) {
585                                         // exit on all block introducers
586                                         case Symbols.TokenIF:
587                                         case Symbols.TokenELSE:
588                                         case Symbols.TokenSYNCHRONIZED:
589                                         case Symbols.TokenCOLON:
590                                         case Symbols.TokenSTATIC:
591                                         case Symbols.TokenCATCH:
592                                         case Symbols.TokenDO:
593                                         case Symbols.TokenWHILE:
594                                         case Symbols.TokenFINALLY:
595                                         case Symbols.TokenFOR:
596                                         case Symbols.TokenTRY:
597                                                 return fPosition;
598
599                                         case Symbols.TokenSWITCH:
600                                                 fIndent= prefCaseIndent();
601                                                 return fPosition;
602                                 }
603                         }
604
605                         switch (fToken) {
606                                 // scope introduction through: LPAREN, LBRACE, LBRACKET
607                                 // search stop on SEMICOLON, RBRACE, COLON, EOF
608                                 // -> the next token is the start of the statement (i.e. previousPos when backward scanning)
609                                 case Symbols.TokenLPAREN:
610                                 case Symbols.TokenLBRACE:
611                                 case Symbols.TokenLBRACKET:
612                                 case Symbols.TokenSEMICOLON:
613                                 case Symbols.TokenEOF:
614                                         return fPreviousPos;
615
616                                 case Symbols.TokenCOLON:
617                                         int pos= fPreviousPos;
618                                         if (!isConditional())
619                                                 return pos;
620                                         break;
621
622                                 case Symbols.TokenRBRACE:
623                                         // RBRACE is a little tricky: it can be the end of an array definition, but
624                                         // usually it is the end of a previous block
625                                         pos= fPreviousPos; // store state
626                                         if (skipScope() && looksLikeArrayInitializerIntro())
627                                                 continue; // it's an array
628                                         else
629                                                 return pos; // it's not - do as with all the above
630
631                                 // scopes: skip them
632                                 case Symbols.TokenRPAREN:
633                                 case Symbols.TokenRBRACKET:
634                                         pos= fPreviousPos;
635                                         if (skipScope())
636                                                 break;
637                                         else
638                                                 return pos;
639
640                                 // IF / ELSE: align the position after the conditional block with the if
641                                 // so we are ready for an else, except if danglingElse is false
642                                 // in order for this to work, we must skip an else to its if
643                                 case Symbols.TokenIF:
644                                         if (danglingElse)
645                                                 return fPosition;
646                                         else
647                                                 break;
648                                 case Symbols.TokenELSE:
649                                         // skip behind the next if, as we have that one covered
650                                         pos= fPosition;
651                                         if (skipNextIF())
652                                                 break;
653                                         else
654                                                 return pos;
655
656                                 case Symbols.TokenDO:
657                                         // align the WHILE position with its do
658                                         return fPosition;
659
660                                 case Symbols.TokenWHILE:
661                                         // this one is tricky: while can be the start of a while loop
662                                         // or the end of a do - while
663                                         pos= fPosition;
664                                         if (hasMatchingDo()) {
665                                                 // continue searching from the DO on
666                                                 break;
667                                         } else {
668                                                 // continue searching from the WHILE on
669                                                 fPosition= pos;
670                                                 break;
671                                         }
672                                 default:
673                                         // keep searching
674
675                         }
676
677                 }
678         }
679
680         /**
681          * Returns true if the colon at the current position is part of a conditional
682          * (ternary) expression, false otherwise.
683          * 
684          * @return true if the colon at the current position is part of a conditional
685          */
686         private boolean isConditional() {
687                 while (true) {
688                         nextToken();
689                         switch (fToken) {
690
691                                 // search for case, otherwise return true
692                                 case Symbols.TokenIDENT:
693                                         continue;
694                                 case Symbols.TokenCASE:
695                                         return false;
696
697                                 default:
698                                         return true;
699                         }
700                 }
701         }
702
703         /**
704          * Returns as a reference any previous <code>switch</code> labels (<code>case</code>
705          * or <code>default</code>) or the offset of the brace that scopes the switch 
706          * statement. Sets <code>fIndent</code> to <code>prefCaseIndent</code> upon
707          * a match.
708          *  
709          * @return the reference offset for a <code>switch</code> label
710          */
711 //      private int matchCaseAlignment() {
712 //              while (true) {
713 //                      nextToken();
714 //                      switch (fToken) {
715 //                              // invalid cases: another case label or an LBRACE must come before a case
716 //                              // -> bail out with the current position
717 //                              case Symbols.TokenLPAREN:
718 //                              case Symbols.TokenLBRACKET:
719 //                              case Symbols.TokenEOF:
720 //                                      return fPosition;
721 //                              case Symbols.TokenLBRACE:
722 //                                      // opening brace of switch statement
723 //                                      fIndent= prefCaseIndent();
724 //                                      return fPosition;
725 //                              case Symbols.TokenCASE:
726 //                              case Symbols.TokenDEFAULT:
727 //                                      // align with previous label
728 //                                      fIndent= 0;
729 //                                      return fPosition;
730 //
731 //                              // scopes: skip them
732 //                              case Symbols.TokenRPAREN:
733 //                              case Symbols.TokenRBRACKET:
734 //                              case Symbols.TokenRBRACE:
735 //                                      skipScope();
736 //                                      break;
737 //
738 //                              default:
739 //                                      // keep searching
740 //                                      continue;
741 //
742 //                      }
743 //              }
744 //      }
745
746         /**
747          * Returns the reference position for a list element. The algorithm
748          * tries to match any previous indentation on the same list. If there is none,
749          * the reference position returned is determined depending on the type of list:
750          * The indentation will either match the list scope introducer (e.g. for
751          * method declarations), so called deep indents, or simply increase the
752          * indentation by a number of standard indents. See also {@link #handleScopeIntroduction(int)}.
753          * 
754          * @return the reference position for a list item: either a previous list item
755          * that has its own indentation, or the list introduction start.
756          */
757         private int skipToPreviousListItemOrListStart() {
758                 int startLine= fLine;
759                 int startPosition= fPosition;
760                 while (true) {
761                         nextToken();
762
763                         // if any line item comes with its own indentation, adapt to it
764                         if (fLine < startLine) {
765                                 try {
766                                         int lineOffset= fDocument.getLineOffset(startLine);
767                                         int bound= Math.min(fDocument.getLength(), startPosition + 1);
768                                         fAlign= fScanner.findNonWhitespaceForwardInAnyPartition(lineOffset, bound);
769                                 } catch (BadLocationException e) {
770                                         // ignore and return just the position
771                                 }
772                                 return startPosition;
773                         }
774
775                         switch (fToken) {
776                                 // scopes: skip them
777                                 case Symbols.TokenRPAREN:
778                                 case Symbols.TokenRBRACKET:
779                                 case Symbols.TokenRBRACE:
780                                         skipScope();
781                                         break;
782
783                                 // scope introduction: special treat who special is
784                                 case Symbols.TokenLPAREN:
785                                 case Symbols.TokenLBRACE:
786                                 case Symbols.TokenLBRACKET:
787                                         return handleScopeIntroduction(startPosition + 1);
788
789                                 case Symbols.TokenSEMICOLON:
790                                         return fPosition;
791                                 case Symbols.TokenQUESTIONMARK:
792                                         if (prefTernaryDeepAlign()) {
793                                                 setFirstElementAlignment(fPosition - 1, fPosition + 1);
794                                                 return fPosition;
795                                         } else {
796                                                 fIndent= prefTernaryIndent();
797                                                 return fPosition;
798                                         }
799                                 case Symbols.TokenEOF:
800                                         return 0;
801
802                         }
803                 }
804         }
805
806         /**
807          * Skips a scope and positions the cursor (<code>fPosition</code>) on the 
808          * token that opens the scope. Returns <code>true</code> if a matching peer
809          * could be found, <code>false</code> otherwise. The current token when calling
810          * must be one out of <code>Symbols.TokenRPAREN</code>, <code>Symbols.TokenRBRACE</code>,
811          * and <code>Symbols.TokenRBRACKET</code>.  
812          * 
813          * @return <code>true</code> if a matching peer was found, <code>false</code> otherwise
814          */
815         private boolean skipScope() {
816                 switch (fToken) {
817                         case Symbols.TokenRPAREN:
818                                 return skipScope(Symbols.TokenLPAREN, Symbols.TokenRPAREN);
819                         case Symbols.TokenRBRACKET:
820                                 return skipScope(Symbols.TokenLBRACKET, Symbols.TokenRBRACKET);
821                         case Symbols.TokenRBRACE:
822                                 return skipScope(Symbols.TokenLBRACE, Symbols.TokenRBRACE);
823                         default:
824                                 Assert.isTrue(false);
825                                 return false;
826                 }
827         }
828
829         /**
830          * Handles the introduction of a new scope. The current token must be one out
831          * of <code>Symbols.TokenLPAREN</code>, <code>Symbols.TokenLBRACE</code>,
832          * and <code>Symbols.TokenLBRACKET</code>. Returns as the reference position
833          * either the token introducing the scope or - if available - the first
834          * java token after that.
835          * 
836          * <p>Depending on the type of scope introduction, the indentation will align
837          * (deep indenting) with the reference position (<code>fAlign</code> will be 
838          * set to the reference position) or <code>fIndent</code> will be set to 
839          * the number of indentation units.
840          * </p>
841          * 
842          * @param bound the bound for the search for the first token after the scope 
843          * introduction.
844          * @return
845          */
846         private int handleScopeIntroduction(int bound) {
847                 switch (fToken) {
848                         // scope introduction: special treat who special is
849                         case Symbols.TokenLPAREN:
850                                 int pos= fPosition; // store
851
852                                 // special: method declaration deep indentation
853                                 if (looksLikeMethodDecl()) {
854                                         if (prefMethodDeclDeepIndent())
855                                                 return setFirstElementAlignment(pos, bound);
856                                         else {
857                                                 fIndent= prefMethodDeclIndent();
858                                                 return pos;
859                                         }
860                                 } else {
861                                         fPosition= pos;
862                                         if (looksLikeMethodCall()) {
863                                                 if (prefMethodCallDeepIndent())
864                                                         return setFirstElementAlignment(pos, bound);
865                                                 else {
866                                                         fIndent= prefMethodCallIndent();
867                                                         return pos;
868                                                 }
869                                         } else if (prefParenthesisDeepIndent())
870                                                 return setFirstElementAlignment(pos, bound);
871                                 }
872
873                                 // normal: return the parenthesis as reference
874                                 fIndent= prefParenthesisIndent();
875                                 return pos;
876
877                         case Symbols.TokenLBRACE:
878                                 pos= fPosition; // store
879
880                                 // special: array initializer
881                                 if (looksLikeArrayInitializerIntro())
882                                         if (prefArrayDeepIndent())
883                                                 return setFirstElementAlignment(pos, bound);
884                                         else
885                                                 fIndent= prefArrayIndent();
886                                 else
887                                         fIndent= prefBlockIndent();
888
889                                 // normal: skip to the statement start before the scope introducer
890                                 // opening braces are often on differently ending indents than e.g. a method definition
891                                 fPosition= pos; // restore
892                                 return skipToStatementStart(true, true); // set to true to match the first if
893
894                         case Symbols.TokenLBRACKET:
895                                 pos= fPosition; // store
896
897                                 // special: method declaration deep indentation
898                                 if (prefArrayDimensionsDeepIndent()) {
899                                         return setFirstElementAlignment(pos, bound);
900                                 }
901
902                                 // normal: return the bracket as reference
903                                 fIndent= prefBracketIndent();
904                                 return pos; // restore
905
906                         default:
907                                 Assert.isTrue(false);
908                                 return -1; // dummy
909                 }
910         }
911
912         /**
913          * Sets the deep indent offset (<code>fAlign</code>) to either the offset
914          * right after <code>scopeIntroducerOffset</code> or - if available - the
915          * first Java token after <code>scopeIntroducerOffset</code>, but before
916          * <code>bound</code>.
917          * 
918          * @param scopeIntroducerOffset the offset of the scope introducer
919          * @param bound the bound for the search for another element
920          * @return the reference position
921          */
922         private int setFirstElementAlignment(int scopeIntroducerOffset, int bound) {
923                 int firstPossible= scopeIntroducerOffset + 1; // align with the first position after the scope intro
924                 fAlign= fScanner.findNonWhitespaceForwardInAnyPartition(firstPossible, bound);
925                 if (fAlign == JavaHeuristicScanner.NOT_FOUND)
926                         fAlign= firstPossible;
927                 return fAlign;
928         }
929
930
931         /**
932          * Returns <code>true</code> if the next token received after calling
933          * <code>nextToken</code> is either an equal sign or an array designator ('[]').
934          * 
935          * @return <code>true</code> if the next elements look like the start of an array definition
936          */
937         private boolean looksLikeArrayInitializerIntro() {
938                 nextToken();
939                 if (fToken == Symbols.TokenEQUAL || skipBrackets()) {
940                         return true;
941                 }
942                 return false;
943         }
944
945         /**
946          * Skips over the next <code>if</code> keyword. The current token when calling
947          * this method must be an <code>else</code> keyword. Returns <code>true</code>
948          * if a matching <code>if</code> could be found, <code>false</code> otherwise.
949          * The cursor (<code>fPosition</code>) is set to the offset of the <code>if</code>
950          * token.
951          * 
952          * @return <code>true</code> if a matching <code>if</code> token was found, <code>false</code> otherwise
953          */
954         private boolean skipNextIF() {
955                 Assert.isTrue(fToken == Symbols.TokenELSE);
956
957                 while (true) {
958                         nextToken();
959                         switch (fToken) {
960                                 // scopes: skip them
961                                 case Symbols.TokenRPAREN:
962                                 case Symbols.TokenRBRACKET:
963                                 case Symbols.TokenRBRACE:
964                                         skipScope();
965                                         break;
966
967                                 case Symbols.TokenIF:
968                                         // found it, return
969                                         return true;
970                                 case Symbols.TokenELSE:
971                                         // recursively skip else-if blocks
972                                         skipNextIF();
973                                         break;
974
975                                 // shortcut scope starts
976                                 case Symbols.TokenLPAREN:
977                                 case Symbols.TokenLBRACE:
978                                 case Symbols.TokenLBRACKET:
979                                 case Symbols.TokenEOF:
980                                         return false;
981                                 }
982                 }
983         }
984
985
986         /**
987          * while(condition); is ambiguous when parsed backwardly, as it is a valid
988          * statement by its own, so we have to check whether there is a matching
989          * do. A <code>do</code> can either be separated from the while by a
990          * block, or by a single statement, which limits our search distance.
991          * 
992          * @return <code>true</code> if the <code>while</code> currently in
993          *         <code>fToken</code> has a matching <code>do</code>.
994          */
995         private boolean hasMatchingDo() {
996                 Assert.isTrue(fToken == Symbols.TokenWHILE);
997                 nextToken();
998                 switch (fToken) {
999                         case Symbols.TokenRBRACE:
1000                                 skipScope(); // and fall thru
1001                         case Symbols.TokenSEMICOLON:
1002                                 skipToStatementStart(false, false);
1003                                 return fToken == Symbols.TokenDO;
1004                 }
1005                 return false;
1006         }
1007
1008         /**
1009          * Skips brackets if the current token is a RBRACKET. There can be nothing
1010          * but whitespace in between, this is only to be used for <code>[]</code> elements.
1011          * 
1012          * @return <code>true</code> if a <code>[]</code> could be scanned, the
1013          *         current token is left at the LBRACKET.
1014          */
1015         private boolean skipBrackets() {
1016                 if (fToken == Symbols.TokenRBRACKET) {
1017                         nextToken();
1018                         if (fToken == Symbols.TokenLBRACKET) {
1019                                 return true;
1020                         }
1021                 }
1022                 return false;
1023         }
1024
1025         /**
1026          * Reads the next token in backward direction from the heuristic scanner
1027          * and sets the fields <code>fToken, fPreviousPosition</code> and <code>fPosition</code>
1028          * accordingly.
1029          */
1030         private void nextToken() {
1031                 nextToken(fPosition);
1032         }
1033
1034         /**
1035          * Reads the next token in backward direction of <code>start</code> from
1036          * the heuristic scanner and sets the fields <code>fToken, fPreviousPosition</code>
1037          * and <code>fPosition</code> accordingly.
1038          */
1039         private void nextToken(int start) {
1040                 fToken= fScanner.previousToken(start - 1, JavaHeuristicScanner.UNBOUND);
1041                 fPreviousPos= start;
1042                 fPosition= fScanner.getPosition() + 1;
1043                 try {
1044                         fLine= fDocument.getLineOfOffset(fPosition);
1045                 } catch (BadLocationException e) {
1046                         fLine= -1;
1047                 }
1048         }
1049
1050         /**
1051          * Returns <code>true</code> if the current tokens look like a method
1052          * declaration header (i.e. only the return type and method name). The
1053          * heuristic calls <code>nextToken</code> and expects an identifier
1054          * (method name) and a type declaration (an identifier with optional 
1055          * brackets) which also covers the visibility modifier of constructors; it
1056          * does not recognize package visible constructors. 
1057          * 
1058          * @return <code>true</code> if the current position looks like a method
1059          *         declaration header.
1060          */
1061         private boolean looksLikeMethodDecl() {
1062                 /*
1063                  * TODO This heuristic does not recognize package private constructors
1064                  * since those do have neither type nor visibility keywords.
1065                  * One option would be to go over the parameter list, but that might
1066                  * be empty as well - hard to do without an AST...
1067                  */
1068
1069                 nextToken();
1070                 if (fToken == Symbols.TokenIDENT) { // method name
1071                         do nextToken();
1072                         while (skipBrackets()); // optional brackets for array valued return types
1073                         return fToken == Symbols.TokenIDENT; // type name
1074
1075                 }
1076                 return false;
1077         }
1078
1079         /**
1080          * Returns <code>true</code> if the current tokens look like a method
1081          * call header (i.e. an identifier as opposed to a keyword taking parenthesized
1082          * parameters such as <code>if</code>).
1083          * <p>The heuristic calls <code>nextToken</code> and expects an identifier
1084          * (method name).
1085          * 
1086          * @return <code>true</code> if the current position looks like a method call
1087          *         header.
1088          */
1089         private boolean looksLikeMethodCall() {
1090                 nextToken();
1091                 return fToken == Symbols.TokenIDENT; // method name
1092         }
1093
1094         /**
1095          * Scans tokens for the matching opening peer. The internal cursor
1096          * (<code>fPosition</code>) is set to the offset of the opening peer if found.
1097          * 
1098          * @return <code>true</code> if a matching token was found, <code>false</code>
1099          *         otherwise
1100          */
1101         private boolean skipScope(int openToken, int closeToken) {
1102
1103                 int depth= 1;
1104
1105                 while (true) {
1106                         nextToken();
1107
1108                         if (fToken == closeToken) {
1109                                 depth++;
1110                         } else if (fToken == openToken) {
1111                                 depth--;
1112                                 if (depth == 0)
1113                                         return true;
1114                         } else if (fToken == Symbols.TokenEOF) {
1115                                         return false;
1116                         }
1117                 }
1118         }
1119
1120         // TODO adjust once there are per-project settings
1121
1122         private int prefTabLength() {
1123                 int tabLen;
1124 //              JavaCore core= JavaCore.getJavaCore();
1125                 PHPeclipsePlugin plugin= PHPeclipsePlugin.getDefault();
1126 //              if (core != null && plugin != null)
1127                   if (plugin != null)
1128                         if (JavaCore.SPACE.equals(JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR)))
1129                                 // if the formatter uses chars to mark indentation, then don't substitute any chars
1130                                 tabLen= -1; // results in no tabs being substituted for space runs
1131                         else
1132                                 // if the formatter uses tabs to mark indentations, use the visual setting from the editor
1133                                 // to get nicely aligned indentations
1134                                 tabLen= plugin.getPreferenceStore().getInt(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_TAB_WIDTH);
1135                 else
1136                         tabLen= 4; // sensible default for testing
1137
1138                 return tabLen;
1139         }
1140
1141         private boolean prefArrayDimensionsDeepIndent() {
1142                 return true; // sensible default
1143         }
1144
1145         private int prefArrayIndent() {
1146                 Plugin plugin= JavaCore.getPlugin();
1147                 if (plugin != null) {
1148                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER);
1149                         try {
1150                                 if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)
1151                                         return 1;
1152                         } catch (IllegalArgumentException e) {
1153                                 // ignore and return default
1154                         }
1155                 }
1156
1157                 return prefContinuationIndent(); // default
1158         }
1159
1160         private boolean prefArrayDeepIndent() {
1161                 Plugin plugin= JavaCore.getPlugin();
1162                 if (plugin != null) {
1163                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER);
1164                         try {
1165                                 return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;
1166                         } catch (IllegalArgumentException e) {
1167                                 // ignore and return default
1168                         }
1169                 }
1170
1171                 return true;
1172         }
1173
1174         private boolean prefTernaryDeepAlign() {
1175                 Plugin plugin= JavaCore.getPlugin();
1176                 if (plugin != null) {
1177                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION);
1178                         try {
1179                                 return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;
1180                         } catch (IllegalArgumentException e) {
1181                                 // ignore and return default
1182                         }
1183                 }
1184                 return false;
1185         }
1186
1187         private int prefTernaryIndent() {
1188                 Plugin plugin= JavaCore.getPlugin();
1189                 if (plugin != null) {
1190                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION);
1191                         try {
1192                                 if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)
1193                                         return 1;
1194                                 else
1195                                         return prefContinuationIndent();
1196                         } catch (IllegalArgumentException e) {
1197                                 // ignore and return default
1198                         }
1199                 }
1200
1201                 return prefContinuationIndent();
1202         }
1203
1204         private int prefCaseIndent() {
1205                 Plugin plugin= JavaCore.getPlugin();
1206                 if (plugin != null) {
1207                         if (DefaultCodeFormatterConstants.TRUE.equals(JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH)))
1208                                 return prefBlockIndent();
1209                         else
1210                                 return 0;
1211                 }
1212
1213                 return 0; // sun standard
1214         }
1215
1216         private int prefAssignmentIndent() {
1217                 return prefBlockIndent();
1218         }
1219
1220         private int prefCaseBlockIndent() {
1221                 if (true)
1222                         return prefBlockIndent();
1223
1224                 Plugin plugin= JavaCore.getPlugin();
1225                 if (plugin != null) {
1226                         if (DefaultCodeFormatterConstants.TRUE.equals(JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES)))
1227                                 return prefBlockIndent();
1228                         else
1229                                 return 0;
1230                 }
1231                 return prefBlockIndent(); // sun standard
1232         }
1233
1234         private int prefSimpleIndent() {
1235                 return prefBlockIndent();
1236         }
1237
1238         private int prefBracketIndent() {
1239                 return prefBlockIndent();
1240         }
1241
1242         private boolean prefMethodDeclDeepIndent() {
1243                 Plugin plugin= JavaCore.getPlugin();
1244                 if (plugin != null) {
1245                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION);
1246                         try {
1247                                 return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;
1248                         } catch (IllegalArgumentException e) {
1249                                 // ignore and return default
1250                         }
1251                 }
1252
1253                 return true;
1254         }
1255
1256         private int prefMethodDeclIndent() {
1257                 Plugin plugin= JavaCore.getPlugin();
1258                 if (plugin != null) {
1259                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION);
1260                         try {
1261                                 if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)
1262                                         return 1;
1263                                 else
1264                                         return prefContinuationIndent();
1265                         } catch (IllegalArgumentException e) {
1266                                 // ignore and return default
1267                         }
1268                 }
1269                 return 1;
1270         }
1271
1272         private boolean prefMethodCallDeepIndent() {
1273                 Plugin plugin= JavaCore.getPlugin();
1274                 if (plugin != null) {
1275                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION);
1276                         try {
1277                                 return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;
1278                         } catch (IllegalArgumentException e) {
1279                                 // ignore and return default
1280                         }
1281                 }
1282                 return false; // sensible default
1283         }
1284
1285         private int prefMethodCallIndent() {
1286                 Plugin plugin= JavaCore.getPlugin();
1287                 if (plugin != null) {
1288                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION);
1289                         try {
1290                                 if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)
1291                                         return 1;
1292                                 else
1293                                         return prefContinuationIndent();
1294                         } catch (IllegalArgumentException e) {
1295                                 // ignore and return default
1296                         }
1297                 }
1298
1299                 return 1; // sensible default
1300         }
1301
1302         private boolean prefParenthesisDeepIndent() {
1303
1304                 if (true) // don't do parenthesis deep indentation
1305                         return false;
1306
1307                 Plugin plugin= JavaCore.getPlugin();
1308                 if (plugin != null) {
1309                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION);
1310                         try {
1311                                 return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;
1312                         } catch (IllegalArgumentException e) {
1313                                 // ignore and return default
1314                         }
1315                 }
1316
1317                 return false; // sensible default
1318         }
1319
1320         private int prefParenthesisIndent() {
1321                 return prefContinuationIndent();
1322         }
1323
1324         private int prefBlockIndent() {
1325                 return 1; // sensible default
1326         }
1327
1328         private boolean prefIndentBracesForBlocks() {
1329                 Plugin plugin= JavaCore.getPlugin();
1330                 if (plugin != null) {
1331                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK);
1332                         return option.equals(DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED);
1333                 }
1334
1335                 return false; // sensible default
1336         }
1337
1338         private boolean prefIndentBracesForArrays() {
1339                 Plugin plugin= JavaCore.getPlugin();
1340                 if (plugin != null) {
1341                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER);
1342                         return option.equals(DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED);
1343                 }
1344
1345                 return false; // sensible default
1346         }
1347
1348         private boolean prefIndentBracesForMethods() {
1349                 Plugin plugin= JavaCore.getPlugin();
1350                 if (plugin != null) {
1351                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION);
1352                         return option.equals(DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED);
1353                 }
1354
1355                 return false; // sensible default
1356         }
1357
1358         private int prefContinuationIndent() {
1359                 Plugin plugin= JavaCore.getPlugin();
1360                 if (plugin != null) {
1361                         String option= JavaCore.getOption(DefaultCodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION);
1362                         try {
1363                                 return Integer.parseInt(option);
1364                         } catch (NumberFormatException e) {
1365                                 // ignore and return default
1366                         }
1367                 }
1368
1369                 return 2; // sensible default
1370         }
1371
1372 }