1 /*******************************************************************************

     2  * Copyright (c) 2000, 2009 IBM Corporation and others.

     3  * All rights reserved. This program and the accompanying materials

     4  * are made available under the terms of the Eclipse Public License v1.0

     5  * which accompanies this distribution, and is available at

     6  * http://www.eclipse.org/legal/epl-v10.html

     7  *

     8  * Contributors:

     9  *     IBM Corporation - initial API and implementation

    10  *     Sergey Prigogin (Google)

    11  *     Anton Leherbauer (Wind River Systems)

    12  *******************************************************************************/

    13 package org.eclipse.cdt.internal.ui.text;

    14 

    15 import org.eclipse.core.runtime.Assert;

    16 import org.eclipse.core.runtime.Platform;

    17 import org.eclipse.core.runtime.preferences.IPreferencesService;

    18 import org.eclipse.jface.text.BadLocationException;

    19 import org.eclipse.jface.text.IDocument;

    20 import org.eclipse.jface.text.IRegion;

    21 

    22 import org.eclipse.cdt.core.CCorePlugin;

    23 import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;

    24 import org.eclipse.cdt.core.model.ICProject;

    25 

    26 import org.eclipse.cdt.internal.corext.util.CodeFormatterUtil;

    27 

    28 /**

    29  * Uses the {@link org.eclipse.cdt.internal.ui.text.CHeuristicScanner} to

    30  * get the indentation level for a certain position in a document.

    31  *

    32  * <p>

    33  * An instance holds some internal position in the document and is therefore

    34  * not thread-safe.

    35  * </p>

    36  */

    37 public final class CIndenter {

    38 	

    39 	/**

    40 	 * The CDT Core preferences.

    41 	 */

    42 	private final class CorePrefs {

    43 		final boolean prefUseTabs;

    44 		final int prefTabSize;

    45 		final int prefIndentationSize;

    46 		final boolean prefArrayDimensionsDeepIndent;

    47 		final int prefArrayIndent;

    48 		final boolean prefArrayDeepIndent;

    49 		final boolean prefTernaryDeepAlign;

    50 		final int prefTernaryIndent;

    51 		final int prefCaseIndent;

    52 		final int prefCaseBlockIndent;

    53 		final int prefAssignmentIndent;

    54 		final int prefSimpleIndent;

    55 		final int prefBracketIndent;

    56 		final boolean prefMethodDeclDeepIndent;

    57 		final boolean prefMethodDeclFirstParameterDeepIndent;

    58 		final int prefMethodDeclIndent;

    59 		final boolean prefMethodCallDeepIndent;

    60 		final boolean prefMethodCallFirstParameterDeepIndent;

    61 		final int prefMethodCallIndent;

    62 		final boolean prefParenthesisDeepIndent;

    63 		final int prefParenthesisIndent;

    64 		final int prefBlockIndent;

    65 		final int prefMethodBodyIndent;

    66 		final int prefTypeIndent;

    67 		final int prefAccessSpecifierIndent;

    68 		final int prefAccessSpecifierExtraSpaces;

    69 		final int prefNamespaceBodyIndent;

    70 		final boolean prefIndentBracesForBlocks;

    71 		final boolean prefIndentBracesForArrays;

    72 		final boolean prefIndentBracesForMethods;

    73 		final boolean prefIndentBracesForTypes;

    74 		final int prefContinuationIndent;

    75 		final boolean prefHasTemplates;

    76 		final String prefTabChar;

    77 		

    78 		private final ICProject fProject;

    79 

    80 		/**

    81 		 * Returns the possibly project-specific core preference defined under <code>key</code>.

    82 		 *

    83 		 * @param key the key of the preference

    84 		 * @return the value of the preference

    85 		 */

    86 		private String getCoreFormatterOption(String key) {

    87 			if (fProject == null)

    88 				return CCorePlugin.getOption(key);

    89 			return fProject.getOption(key, true);

    90 		}

    91 		

    92 		CorePrefs(ICProject project) {

    93 			fProject= project;

    94 			prefUseTabs= prefUseTabs();

    95 			prefTabSize= prefTabSize();

    96 			prefIndentationSize= prefIndentationSize();

    97 			prefArrayDimensionsDeepIndent= prefArrayDimensionsDeepIndent();

    98 			prefContinuationIndent= prefContinuationIndent();

    99 			prefBlockIndent= prefBlockIndent();

   100 			prefArrayIndent= prefArrayIndent();

   101 			prefArrayDeepIndent= prefArrayDeepIndent();

   102 			prefTernaryDeepAlign= prefTernaryDeepAlign();

   103 			prefTernaryIndent= prefTernaryIndent();

   104 			prefCaseIndent= prefCaseIndent();

   105 			prefCaseBlockIndent= prefCaseBlockIndent();

   106 			prefAssignmentIndent= prefAssignmentIndent();

   107 			prefIndentBracesForBlocks= prefIndentBracesForBlocks();

   108 			prefSimpleIndent= prefSimpleIndent();

   109 			prefBracketIndent= prefBracketIndent();

   110 			prefMethodDeclDeepIndent= prefMethodDeclDeepIndent();

   111 			prefMethodDeclFirstParameterDeepIndent= prefMethodDeclFirstParameterDeepIndent();

   112 			prefMethodDeclIndent= prefMethodDeclIndent();

   113 			prefMethodCallDeepIndent= prefMethodCallDeepIndent();

   114 			prefMethodCallFirstParameterDeepIndent= prefMethodCallFirstParameterDeepIndent();

   115 			prefMethodCallIndent= prefMethodCallIndent();

   116 			prefParenthesisDeepIndent= prefParenthesisDeepIndent();

   117 			prefParenthesisIndent= prefParenthesisIndent();

   118 			prefMethodBodyIndent= prefMethodBodyIndent();

   119 			prefTypeIndent= prefTypeIndent();

   120 			prefAccessSpecifierIndent= prefAccessSpecifierIndent();

   121 			prefAccessSpecifierExtraSpaces= prefAccessSpecifierExtraSpaces();

   122 			prefNamespaceBodyIndent= prefNamespaceBodyIndent();

   123 			prefIndentBracesForArrays= prefIndentBracesForArrays();

   124 			prefIndentBracesForMethods= prefIndentBracesForMethods();

   125 			prefIndentBracesForTypes= prefIndentBracesForTypes();

   126 			prefHasTemplates= hasTemplates();

   127 			prefTabChar= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR);

   128 		}

   129 		

   130 		private boolean prefUseTabs() {

   131 			return !CCorePlugin.SPACE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR));

   132 		}

   133 

   134 		private int prefTabSize() {

   135 			return CodeFormatterUtil.getTabWidth(fProject);

   136 		}

   137 

   138 		private int prefIndentationSize() {

   139 			return CodeFormatterUtil.getIndentWidth(fProject);

   140 		}

   141 

   142 		private boolean prefArrayDimensionsDeepIndent() {

   143 			return true; // sensible default, no formatter setting

   144 		}

   145 

   146 		private int prefArrayIndent() {

   147 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_INITIALIZER_LIST);

   148 			try {

   149 				if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)

   150 					return 1;

   151 			} catch (IllegalArgumentException e) {

   152 				// ignore and return default

   153 			}

   154 

   155 			return prefContinuationIndent(); // default

   156 		}

   157 

   158 		private boolean prefArrayDeepIndent() {

   159 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_INITIALIZER_LIST);

   160 			try {

   161 				return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;

   162 			} catch (IllegalArgumentException e) {

   163 				// ignore and return default

   164 			}

   165 

   166 			return true;

   167 		}

   168 

   169 		private boolean prefTernaryDeepAlign() {

   170 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION);

   171 			try {

   172 				return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;

   173 			} catch (IllegalArgumentException e) {

   174 				// ignore and return default

   175 			}

   176 			return false;

   177 		}

   178 

   179 		private int prefTernaryIndent() {

   180 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION);

   181 			try {

   182 				if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)

   183 					return 1;

   184 				else

   185 					return prefContinuationIndent();

   186 			} catch (IllegalArgumentException e) {

   187 				// ignore and return default

   188 			}

   189 

   190 			return prefContinuationIndent();

   191 		}

   192 

   193 		private int prefCaseIndent() {

   194 			if (DefaultCodeFormatterConstants.TRUE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH)))

   195 				return 1;

   196 			else

   197 				return 0;

   198 		}

   199 

   200 		private int prefCaseBlockIndent() {

   201 			if (DefaultCodeFormatterConstants.TRUE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES)))

   202 				return 1;

   203 			else

   204 				return 0;

   205 		}

   206 

   207 		private int prefAssignmentIndent() {

   208 			return prefContinuationIndent();

   209 		}

   210 

   211 		private int prefSimpleIndent() {

   212 			if (prefIndentBracesForBlocks() && prefBlockIndent() == 0)

   213 				return 1;

   214 			else

   215 				return prefBlockIndent();

   216 		}

   217 

   218 		private int prefBracketIndent() {

   219 			return prefBlockIndent();

   220 		}

   221 

   222 		private boolean prefMethodDeclDeepIndent() {

   223 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION);

   224 			try {

   225 				int indentStyle = DefaultCodeFormatterConstants.getIndentStyle(option);

   226 				return indentStyle == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;

   227 			} catch (IllegalArgumentException e) {

   228 				// ignore and return default

   229 			}

   230 

   231 			return false;

   232 		}

   233 

   234 		private boolean prefMethodDeclFirstParameterDeepIndent() {

   235 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION);

   236 			try {

   237 				int indentStyle = DefaultCodeFormatterConstants.getIndentStyle(option);

   238 				int wrappingStyle = DefaultCodeFormatterConstants.getWrappingStyle(option);

   239 				return indentStyle == DefaultCodeFormatterConstants.INDENT_ON_COLUMN &&

   240 				    	(wrappingStyle == DefaultCodeFormatterConstants.WRAP_COMPACT_FIRST_BREAK ||

   241 				    	wrappingStyle == DefaultCodeFormatterConstants.WRAP_ONE_PER_LINE);

   242 			} catch (IllegalArgumentException e) {

   243 				// ignore and return default

   244 			}

   245 

   246 			return false;

   247 		}

   248 

   249 		private int prefMethodDeclIndent() {

   250 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION);

   251 			try {

   252 				if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)

   253 					return 1;

   254 				else

   255 					return prefContinuationIndent();

   256 			} catch (IllegalArgumentException e) {

   257 				// ignore and return default

   258 			}

   259 			return 1;

   260 		}

   261 

   262 		private boolean prefMethodCallDeepIndent() {

   263 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION);

   264 			try {

   265 				int indentStyle = DefaultCodeFormatterConstants.getIndentStyle(option);

   266 				return indentStyle == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;

   267 			} catch (IllegalArgumentException e) {

   268 				// ignore and return default

   269 			}

   270 			return false; // sensible default

   271 		}

   272 

   273 		private boolean prefMethodCallFirstParameterDeepIndent() {

   274 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION);

   275 			try {

   276 				int indentStyle = DefaultCodeFormatterConstants.getIndentStyle(option);

   277 				int wrappingStyle = DefaultCodeFormatterConstants.getWrappingStyle(option);

   278 				return indentStyle == DefaultCodeFormatterConstants.INDENT_ON_COLUMN &&

   279 				    	(wrappingStyle == DefaultCodeFormatterConstants.WRAP_COMPACT_FIRST_BREAK ||

   280 				        wrappingStyle == DefaultCodeFormatterConstants.WRAP_ONE_PER_LINE);

   281 			} catch (IllegalArgumentException e) {

   282 				// ignore and return default

   283 			}

   284 			return false; // sensible default

   285 		}

   286 

   287 		private int prefMethodCallIndent() {

   288 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION);

   289 			try {

   290 				if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)

   291 					return 1;

   292 				else

   293 					return prefContinuationIndent();

   294 			} catch (IllegalArgumentException e) {

   295 				// ignore and return default

   296 			}

   297 

   298 			return 1; // sensible default

   299 		}

   300 

   301 		private boolean prefParenthesisDeepIndent() {

   302 			// don't do parenthesis deep indentation

   303 //			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION);

   304 //			try {

   305 //				return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;

   306 //			} catch (IllegalArgumentException e) {

   307 //				// ignore and return default

   308 //			}

   309 

   310 			return false;

   311 		}

   312 

   313 		private int prefParenthesisIndent() {

   314 			return prefContinuationIndent();

   315 		}

   316 

   317 		private int prefBlockIndent() {

   318 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK);

   319 			if (DefaultCodeFormatterConstants.FALSE.equals(option))

   320 				return 0;

   321 

   322 			return 1; // sensible default

   323 		}

   324 

   325 		private int prefMethodBodyIndent() {

   326 			if (DefaultCodeFormatterConstants.FALSE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY)))

   327 				return 0;

   328 

   329 			return 1; // sensible default

   330 		}

   331 

   332 		private int prefTypeIndent() {

   333 			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ACCESS_SPECIFIER);

   334 			if (DefaultCodeFormatterConstants.FALSE.equals(option))

   335 				return 0;

   336 

   337 			return 1; // sensible default

   338 		}

   339 		

   340 		private int prefAccessSpecifierIndent() {

   341 			if (DefaultCodeFormatterConstants.TRUE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_ACCESS_SPECIFIER_COMPARE_TO_TYPE_HEADER)))

   342 				return 1;

   343 			else

   344 				return 0;

   345 		}

   346 

   347 		private int prefAccessSpecifierExtraSpaces() {

   348 			// Hidden option that enables fractional indent of access specifiers.

   349 			IPreferencesService prefs = Platform.getPreferencesService();

   350 			return prefs.getInt(CCorePlugin.PLUGIN_ID, CCorePlugin.PLUGIN_ID + ".formatter.indent_access_specifier_extra_spaces", 0, null); //$NON-NLS-1$

   351 		}

   352 

   353 		private int prefNamespaceBodyIndent() {

   354 			if (DefaultCodeFormatterConstants.TRUE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_NAMESPACE_HEADER)))

   355 				return prefBlockIndent();

   356 			else

   357 				return 0;

   358 		}

   359 

   360 		private boolean prefIndentBracesForBlocks() {

   361 			return DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK));

   362 		}

   363 

   364 		private boolean prefIndentBracesForArrays() {

   365 			return DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_INITIALIZER_LIST));

   366 		}

   367 

   368 		private boolean prefIndentBracesForMethods() {

   369 			return DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION));

   370 		}

   371 

   372 		private boolean prefIndentBracesForTypes() {

   373 			return DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION));

   374 		}

   375 

   376 		private int prefContinuationIndent() {

   377 			try {

   378 				return Integer.parseInt(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION));

   379 			} catch (NumberFormatException e) {

   380 				// ignore and return default

   381 			}

   382 

   383 			return 2; // sensible default

   384 		}

   385 		

   386 		private boolean hasTemplates() {

   387 			return true;

   388 		}

   389 	}

   390 

   391 	/** The document being scanned. */

   392 	private final IDocument fDocument;

   393 	/** The indentation accumulated by <code>findReferencePosition</code>. */

   394 	private int fIndent;

   395 	/** Extra spaces to add on top of fIndent */

   396 	private int fExtraSpaces;

   397 	/**

   398 	 * The absolute (character-counted) indentation offset for special cases

   399 	 * (method defs, array initializers)

   400 	 */

   401 	private int fAlign;

   402 	/** The stateful scan position for the indentation methods. */

   403 	private int fPosition;

   404 	/** The previous position. */

   405 	private int fPreviousPos;

   406 	/** The most recent token. */

   407 	private int fToken;

   408 	/** The line of <code>fPosition</code>. */

   409 	private int fLine;

   410 	/**

   411 	 * The scanner we will use to scan the document. It has to be installed

   412 	 * on the same document as the one we get.

   413 	 */

   414 	private final CHeuristicScanner fScanner;

   415 	/**

   416 	 * The CDT Core preferences.

   417 	 */

   418 	private final CorePrefs fPrefs;

   419 

   420 	/**

   421 	 * Creates a new instance.

   422 	 *

   423 	 * @param document the document to scan

   424 	 * @param scanner the {@link CHeuristicScanner} to be used for scanning

   425 	 * the document. It must be installed on the same <code>IDocument</code>.

   426 	 */

   427 	public CIndenter(IDocument document, CHeuristicScanner scanner) {

   428 		this(document, scanner, null);

   429 	}

   430 

   431 	/**

   432 	 * Creates a new instance.

   433 	 *

   434 	 * @param document the document to scan

   435 	 * @param scanner the {@link CHeuristicScanner} to be used for scanning

   436 	 *        the document. It must be installed on the same

   437 	 *        <code>IDocument</code>.

   438 	 * @param project the C/C++ project to get the formatter preferences from, or

   439 	 *        <code>null</code> to use the workspace settings

   440 	 */

   441 	public CIndenter(IDocument document, CHeuristicScanner scanner, ICProject project) {

   442 		Assert.isNotNull(document);

   443 		Assert.isNotNull(scanner);

   444 		fDocument= document;

   445 		fScanner= scanner;

   446 		fPrefs= new CorePrefs(project);

   447 	}

   448 

   449 	/**

   450 	 * Computes the indentation at the reference point of <code>position</code>.

   451 	 *

   452 	 * @param offset the offset in the document

   453 	 * @return a String which reflects the indentation at the line in which the

   454 	 *         reference position to <code>offset</code> resides, or <code>null</code>

   455 	 *         if it cannot be determined

   456 	 */

   457 	public StringBuilder getReferenceIndentation(int offset) {

   458 		return getReferenceIndentation(offset, false);

   459 	}

   460 

   461 	/**

   462 	 * Computes the indentation at the reference point of <code>position</code>.

   463 	 *

   464 	 * @param offset the offset in the document

   465 	 * @param assumeOpeningBrace <code>true</code> if an opening brace should be assumed

   466 	 * @return a String which reflects the indentation at the line in which the

   467 	 *         reference position to <code>offset</code> resides, or <code>null</code>

   468 	 *         if it cannot be determined

   469 	 */

   470 	private StringBuilder getReferenceIndentation(int offset, boolean assumeOpeningBrace) {

   471 		int unit;

   472 		if (assumeOpeningBrace)

   473 			unit= findReferencePosition(offset, Symbols.TokenLBRACE);

   474 		else

   475 			unit= findReferencePosition(offset, peekToken(offset));

   476 

   477 		// if we were unable to find anything, return null

   478 		if (unit == CHeuristicScanner.NOT_FOUND)

   479 			return null;

   480 

   481 		return getLeadingWhitespace(unit);

   482 	}

   483 

   484 	/**

   485 	 * Computes the indentation at <code>offset</code>.

   486 	 *

   487 	 * @param offset the offset in the document

   488 	 * @return a String which reflects the correct indentation for the line in

   489 	 *         which offset resides, or <code>null</code> if it cannot be

   490 	 *         determined

   491 	 */

   492 	public StringBuilder computeIndentation(int offset) {

   493 		return computeIndentation(offset, false);

   494 	}

   495 

   496 	/**

   497 	 * Computes the indentation at <code>offset</code>.

   498 	 *

   499 	 * @param offset the offset in the document

   500 	 * @param assumeOpeningBrace <code>true</code> if an opening brace should be assumed

   501 	 * @return a String which reflects the correct indentation for the line in

   502 	 *         which offset resides, or <code>null</code> if it cannot be

   503 	 *         determined

   504 	 */

   505 	public StringBuilder computeIndentation(int offset, boolean assumeOpeningBrace) {

   506 		StringBuilder reference= getReferenceIndentation(offset, assumeOpeningBrace);

   507 

   508 		// handle special alignment

   509 		if (fAlign != CHeuristicScanner.NOT_FOUND) {

   510 			try {

   511 				// a special case has been detected.

   512 				IRegion line= fDocument.getLineInformationOfOffset(fAlign);

   513 				int lineOffset= line.getOffset();

   514 				return createIndent(lineOffset, fAlign, false);

   515 			} catch (BadLocationException e) {

   516 				return null;

   517 			}

   518 		}

   519 

   520 		if (reference == null)

   521 			return null;

   522 

   523 		// Add additional indent

   524 		return createReusingIndent(reference, fIndent, fExtraSpaces);

   525 	}

   526 

   527 	/**

   528 	 * Computes the indentation for a continuation line at <code>offset</code>.

   529 	 *

   530 	 * @param offset the offset in the document

   531 	 * @return a StringBuilder which reflects the correct indentation for

   532 	 *         the line in  which offset resides, or <code>null</code> if it cannot be

   533 	 *         determined.

   534 	 * @throws BadLocationException

   535 	 */

   536 	public StringBuilder computeContinuationLineIndentation(int offset) throws BadLocationException {

   537 		StringBuilder reference= getLeadingWhitespace(offset);

   538 		IRegion line= fDocument.getLineInformationOfOffset(offset);

   539 		String string= fDocument.get(line.getOffset(), offset - line.getOffset());

   540 		if (string.trim().length() == 0)

   541 			return reference;

   542 		// Add additional indent

   543 		return createReusingIndent(reference, fPrefs.prefContinuationIndent, 0);

   544 	}

   545 	

   546 	/**

   547 	 * Computes the length of a <code>CharacterSequence</code>, counting

   548 	 * a tab character as the size until the next tab stop and every other

   549 	 * character as one.

   550 	 *

   551 	 * @param indent the string to measure

   552 	 * @return the visual length in characters

   553 	 */

   554 	private int computeVisualLength(CharSequence indent) {

   555 		final int tabSize= fPrefs.prefTabSize;

   556 		int length= 0;

   557 		for (int i= 0; i < indent.length(); i++) {

   558 			char ch= indent.charAt(i);

   559 			switch (ch) {

   560 			case '\t':

   561 				if (tabSize > 0) {

   562 					int reminder= length % tabSize;

   563 					length += tabSize - reminder;

   564 				}

   565 				break;

   566 			case ' ':

   567 				length++;

   568 				break;

   569 			}

   570 		}

   571 		return length;

   572 	}

   573 

   574 	/**

   575 	 * Strips any characters off the end of <code>reference</code> that exceed

   576 	 * <code>indentLength</code>.

   577 	 *

   578 	 * @param reference the string to measure

   579 	 * @param indentLength the maximum visual indentation length

   580 	 * @return the stripped <code>reference</code>

   581 	 */

   582 	private StringBuilder stripExceedingChars(StringBuilder reference, int indentLength) {

   583 		final int tabSize= fPrefs.prefTabSize;

   584 		int measured= 0;

   585 		int chars= reference.length();

   586 		int i= 0;

   587 		for (; measured < indentLength && i < chars; i++) {

   588 			char ch= reference.charAt(i);

   589 			switch (ch) {

   590 			case '\t':

   591 				if (tabSize > 0) {

   592 					int reminder= measured % tabSize;

   593 					measured += tabSize - reminder;

   594 				}

   595 				break;

   596 			case ' ':

   597 				measured++;

   598 				break;

   599 			}

   600 		}

   601 		int deleteFrom= measured > indentLength ? i - 1 : i;

   602 

   603 		return reference.delete(deleteFrom, chars);

   604 	}

   605 

   606 	/**

   607 	 * Returns the indentation of the line at <code>offset</code> as a

   608 	 * <code>StringBuilder</code>. If the offset is not valid, the empty string

   609 	 * is returned.

   610 	 *

   611 	 * @param offset the offset in the document

   612 	 * @return the indentation (leading whitespace) of the line in which

   613 	 * 		   <code>offset</code> is located

   614 	 */

   615 	private StringBuilder getLeadingWhitespace(int offset) {

   616 		StringBuilder indent= new StringBuilder();

   617 		try {

   618 			IRegion line= fDocument.getLineInformationOfOffset(offset);

   619 			int lineOffset= line.getOffset();

   620 			int nonWS= fScanner.findNonWhitespaceForwardInAnyPartition(lineOffset, lineOffset + line.getLength());

   621 			indent.append(fDocument.get(lineOffset, nonWS - lineOffset));

   622 			return indent;

   623 		} catch (BadLocationException e) {

   624 			return indent;

   625 		}

   626 	}

   627 

   628 	/**

   629 	 * Creates an indentation string of the length indent - start, consisting of

   630 	 * the content in <code>fDocument</code> in the range [start, indent),

   631 	 * with every character replaced by a space except for tabs, which are kept

   632 	 * as such.

   633 	 * <p>

   634 	 * If <code>convertSpaceRunsToTabs</code> is <code>true</code>, every

   635 	 * run of the number of spaces that make up a tab are replaced by a tab

   636 	 * character. If it is not set, no conversion takes place, but tabs in the

   637 	 * original range are still copied verbatim.

   638 	 * </p>

   639 	 *

   640 	 * @param start the start of the document region to copy the indent from

   641 	 * @param indent the exclusive end of the document region to copy the indent

   642 	 *        from

   643 	 * @param convertSpaceRunsToTabs whether to convert consecutive runs of

   644 	 *        spaces to tabs

   645 	 * @return the indentation corresponding to the document content specified

   646 	 *         by <code>start</code> and <code>indent</code>

   647 	 */

   648 	private StringBuilder createIndent(int start, final int indent, final boolean convertSpaceRunsToTabs) {

   649 		final boolean convertTabs= fPrefs.prefUseTabs && convertSpaceRunsToTabs;

   650 		final int tabLen= fPrefs.prefTabSize;

   651 		final StringBuilder ret= new StringBuilder();

   652 		try {

   653 			int spaces= 0;

   654 			while (start < indent) {

   655 				char ch= fDocument.getChar(start);

   656 				if (ch == '\t') {

   657 					ret.append('\t');

   658 					spaces= 0;

   659 				} else if (convertTabs) {

   660 					spaces++;

   661 					if (spaces == tabLen) {

   662 						ret.append('\t');

   663 						spaces= 0;

   664 					}

   665 				} else {

   666 					ret.append(' ');

   667 				}

   668 

   669 				start++;

   670 			}

   671 			// remainder

   672 			while (spaces-- > 0)

   673 				ret.append(' ');

   674 		} catch (BadLocationException e) {

   675 		}

   676 

   677 		return ret;

   678 	}

   679 

   680 	/**

   681 	 * Creates a string with a visual length of the given

   682 	 * <code>indentationSize</code>.

   683 	 *

   684 	 * @param buffer the original indent to reuse if possible

   685 	 * @param additional the additional indentation units to add or subtract to

   686 	 *        reference

   687 	 * @param extraSpaces additional spaces to add to indentation.

   688 	 * @return the modified <code>buffer</code> reflecting the indentation

   689 	 *         adapted to <code>additional</code>

   690 	 */

   691 	public StringBuilder createReusingIndent(StringBuilder buffer, int additional, int extraSpaces) {

   692 		int refLength= computeVisualLength(buffer);

   693 		int addLength= fPrefs.prefIndentationSize * additional + extraSpaces; // may be < 0

   694 		int totalLength= Math.max(0, refLength + addLength);

   695 

   696 		// copy the reference indentation for the indent up to the last tab

   697 		// stop within the maxCopy area

   698 		int minLength= Math.min(totalLength, refLength);

   699 		int tabSize= fPrefs.prefTabSize;

   700 		int maxCopyLength= tabSize > 0 ? minLength - minLength % tabSize : minLength; // maximum indent to copy

   701 		stripExceedingChars(buffer, maxCopyLength);

   702 

   703 		// add additional indent

   704 		int missing= totalLength - maxCopyLength;

   705 		final int tabs, spaces;

   706 		if (CCorePlugin.SPACE.equals(fPrefs.prefTabChar)) {

   707 			tabs= 0;

   708 			spaces= missing;

   709 		} else {

   710 			tabs= tabSize > 0 ? missing / tabSize : 0;

   711 			spaces= tabSize > 0 ? missing % tabSize : missing;

   712 		}

   713 		for (int i= 0; i < tabs; i++)

   714 			buffer.append('\t');

   715 		for (int i= 0; i < spaces; i++)

   716 			buffer.append(' ');

   717 		return buffer;

   718 	}

   719 

   720 	/**

   721 	 * Returns relative indent of continuation lines.

   722 	 * @return a number of indentation units.

   723 	 */

   724 	public int getContinuationLineIndent() {

   725 		return fPrefs.prefContinuationIndent;

   726 	}

   727 

   728 	/**

   729 	 * Returns the reference position regarding to indentation for <code>offset</code>,

   730 	 * or <code>NOT_FOUND</code>. This method calls

   731 	 * {@link #findReferencePosition(int, int) findReferencePosition(offset, nextChar)} where

   732 	 * <code>nextChar</code> is the next character after <code>offset</code>.

   733 	 *

   734 	 * @param offset the offset for which the reference is computed

   735 	 * @return the reference statement relative to which <code>offset</code>

   736 	 *         should be indented, or {@link CHeuristicScanner#NOT_FOUND}

   737 	 */

   738 	public int findReferencePosition(int offset) {

   739 		return findReferencePosition(offset, peekToken(offset));

   740 	}

   741 

   742 	/**

   743 	 * Peeks the next token in the document that comes after <code>offset</code>

   744 	 * on the same line as <code>offset</code>.

   745 	 *

   746 	 * @param offset the offset into document

   747 	 * @return the token symbol of the next element, or TokenEOF if there is none

   748 	 */

   749 	private int peekToken(int offset) {

   750 		if (offset < fDocument.getLength()) {

   751 			try {

   752 				IRegion line= fDocument.getLineInformationOfOffset(offset);

   753 				int lineOffset= line.getOffset();

   754 				int next= fScanner.nextToken(offset, lineOffset + line.getLength());

   755 				return next;

   756 			} catch (BadLocationException e) {

   757 			}

   758 		}

   759 		return Symbols.TokenEOF;

   760 	}

   761 

   762 	/**

   763 	 * Returns the reference position regarding to indentation for <code>position</code>,

   764 	 * or <code>NOT_FOUND</code>.

   765 	 *

   766 	 * <p>If <code>peekNextChar</code> is <code>true</code>, the next token after

   767 	 * <code>offset</code> is read and taken into account when computing the

   768 	 * indentation. Currently, if the next token is the first token on the line

   769 	 * (i.e. only preceded by whitespace), the following tokens are specially

   770 	 * handled:

   771 	 * <ul>

   772 	 * 	<li><code>switch</code> labels are indented relative to the switch block</li>

   773 	 * 	<li>opening curly braces are aligned correctly with the introducing code</li>

   774 	 * 	<li>closing curly braces are aligned properly with the introducing code of

   775 	 * 		the matching opening brace</li>

   776 	 * 	<li>closing parenthesis' are aligned with their opening peer</li>

   777 	 * 	<li>the <code>else</code> keyword is aligned with its <code>if</code>, anything

   778 	 * 		else is aligned normally (i.e. with the base of any introducing statements).</li>

   779 	 *  <li>if there is no token on the same line after <code>offset</code>, the indentation

   780 	 * 		is the same as for an <code>else</code> keyword</li>

   781 	 * </ul>

   782 	 *

   783 	 * @param offset the offset for which the reference is computed

   784 	 * @param nextToken the next token to assume in the document

   785 	 * @return the reference statement relative to which <code>offset</code>

   786 	 *         should be indented, or {@link CHeuristicScanner#NOT_FOUND}

   787 	 */

   788 	public int findReferencePosition(int offset, int nextToken) {

   789 		boolean danglingElse= false;

   790 		boolean cancelIndent= false; // If set to true, fIndent is ignored.

   791 		int extraIndent= 0; // Can be either positive or negative.

   792 		boolean matchBrace= false;

   793 		boolean matchParen= false;

   794 		boolean matchCase= false;

   795 		boolean matchAccessSpecifier= false;

   796 

   797 		// Account for un-indentation characters already typed in, but after position.

   798 		// If they are on a line by themselves, the indentation gets adjusted accordingly.

   799 		//

   800 		// Also account for a dangling else.

   801 		if (offset < fDocument.getLength()) {

   802 			try {

   803 				IRegion line= fDocument.getLineInformationOfOffset(offset);

   804 				int lineOffset= line.getOffset();

   805 				int prevPos= Math.max(offset - 1, 0);

   806 				boolean isFirstTokenOnLine= fDocument.get(lineOffset, prevPos + 1 - lineOffset).trim().length() == 0;

   807 				int prevToken= fScanner.previousToken(prevPos, CHeuristicScanner.UNBOUND);

   808 				boolean bracelessBlockStart= fScanner.isBracelessBlockStart(prevPos, CHeuristicScanner.UNBOUND);

   809 

   810 				switch (nextToken) {

   811 				case Symbols.TokenELSE:

   812 					danglingElse= true;

   813 					break;

   814 					

   815 				case Symbols.TokenCASE:

   816 				case Symbols.TokenDEFAULT:

   817 					if (isFirstTokenOnLine)

   818 						matchCase= true;

   819 					break;

   820 					

   821 				case Symbols.TokenPUBLIC:

   822 				case Symbols.TokenPROTECTED:

   823 				case Symbols.TokenPRIVATE:

   824 					if (isFirstTokenOnLine)

   825 						matchAccessSpecifier= true;

   826 					break;

   827 					

   828 				case Symbols.TokenLBRACE: // for opening-brace-on-new-line style

   829 					if (bracelessBlockStart) {

   830 						extraIndent= fPrefs.prefIndentBracesForBlocks ? 0 : -1;

   831 					} else if (prevToken == Symbols.TokenCOLON && !fPrefs.prefIndentBracesForBlocks) {

   832 						extraIndent= -1;

   833 					} else if ((prevToken == Symbols.TokenEQUAL || prevToken == Symbols.TokenRBRACKET) &&

   834 							!fPrefs.prefIndentBracesForArrays) {

   835 						cancelIndent= true;

   836 					} else if (prevToken == Symbols.TokenRPAREN && fPrefs.prefIndentBracesForMethods) {

   837 						extraIndent= 1;

   838 					} else if (prevToken == Symbols.TokenIDENT && fPrefs.prefIndentBracesForTypes) {

   839 						extraIndent= 1;

   840 					}

   841 					break;

   842 					

   843 				case Symbols.TokenRBRACE: // closing braces get unindented

   844 					if (isFirstTokenOnLine || prevToken != Symbols.TokenLBRACE)

   845 						matchBrace= true;

   846 					break;

   847 					

   848 				case Symbols.TokenRPAREN:

   849 					if (isFirstTokenOnLine)

   850 						matchParen= true;

   851 					break;

   852 				}

   853 			} catch (BadLocationException e) {

   854 			}

   855 		} else {

   856 			// don't assume an else could come if we are at the end of file

   857 			danglingElse= false;

   858 		}

   859 

   860 		int ref= findReferencePosition(offset, danglingElse, matchBrace, matchParen, matchCase,

   861 				matchAccessSpecifier);

   862 		if (cancelIndent) {

   863 			fIndent = 0;

   864 		} else if (extraIndent > 0) {

   865 			fAlign= CHeuristicScanner.NOT_FOUND;

   866 			fIndent += extraIndent;

   867 		} else {

   868 			fIndent += extraIndent;

   869 		}

   870 		return ref;

   871 	}

   872 

   873 	/**

   874 	 * Returns the reference position regarding to indentation for <code>position</code>,

   875 	 * or <code>NOT_FOUND</code>.<code>fIndent</code> will contain the

   876 	 * relative indentation (in indentation units, not characters) after the

   877 	 * call. If there is a special alignment (e.g. for a method declaration

   878 	 * where parameters should be aligned), <code>fAlign</code> will contain

   879 	 * the absolute position of the alignment reference in <code>fDocument</code>,

   880 	 * otherwise <code>fAlign</code> is set to <code>CHeuristicScanner.NOT_FOUND</code>.

   881 	 *

   882 	 * @param offset the offset for which the reference is computed

   883 	 * @param danglingElse whether a dangling else should be assumed at <code>position</code>

   884 	 * @param matchBrace whether the position of the matching brace should be

   885 	 *            returned instead of doing code analysis

   886 	 * @param matchParen whether the position of the matching parenthesis

   887 	 *            should be returned instead of doing code analysis

   888 	 * @param matchCase whether the position of a switch statement reference

   889 	 *            should be returned (either an earlier case statement or the

   890 	 *            switch block brace)

   891 	 * @param matchAccessSpecifier whether the position of a class body reference

   892 	 *            should be returned (either an earlier public/protected/private

   893 	 *            or the class body brace)

   894 	 * @return the reference statement relative to which <code>position</code>

   895 	 *         should be indented, or {@link CHeuristicScanner#NOT_FOUND}

   896 	 */

   897 	public int findReferencePosition(int offset, boolean danglingElse, boolean matchBrace, boolean matchParen,

   898 			boolean matchCase, boolean matchAccessSpecifier) {

   899 		fIndent= 0; // the indentation modification

   900 		fAlign= CHeuristicScanner.NOT_FOUND;

   901 		fPosition= offset;

   902 

   903 		// forward cases

   904 		// An unindentation happens sometimes if the next token is special, namely on braces, parens and case

   905 		// labels align braces, but handle the case where we align with the method declaration start instead

   906 		// of the opening brace.

   907 		if (matchBrace) {

   908 			if (skipScope(Symbols.TokenLBRACE, Symbols.TokenRBRACE)) {

   909 				try {

   910 					// Align with the opening brace that is on a line by its own

   911 					int lineOffset= fDocument.getLineOffset(fLine);

   912 					if (lineOffset <= fPosition && fDocument.get(lineOffset, fPosition - lineOffset).trim().length() == 0)

   913 						return fPosition;

   914 				} catch (BadLocationException e) {

   915 					// Concurrent modification - walk default path

   916 				}

   917 				// If the opening brace is not on the start of the line, skip to the start

   918 				int pos= skipToStatementStart(true, true);

   919 				fIndent= 0; // indent is aligned with reference position

   920 				return pos;

   921 			} else {

   922 				// If we can't find the matching brace, the heuristic is to unindent

   923 				// by one against the normal position

   924 				int pos= findReferencePosition(offset, danglingElse, false, matchParen, matchCase,

   925 						matchAccessSpecifier);

   926 				fIndent--;

   927 				return pos;

   928 			}

   929 		}

   930 

   931 		// Align parentheses

   932 		if (matchParen) {

   933 			if (skipScope(Symbols.TokenLPAREN, Symbols.TokenRPAREN)) {

   934 				return fPosition;

   935 			} else {

   936 				// if we can't find the matching paren, the heuristic is to unindent

   937 				// by one against the normal position

   938 				int pos= findReferencePosition(offset, danglingElse, matchBrace, false, matchCase,

   939 						matchAccessSpecifier);

   940 				fIndent--;

   941 				return pos;

   942 			}

   943 		}

   944 

   945 		// The only reliable way to get case labels aligned (due to many different styles of using braces in

   946 		// a block) is to go for another case statement, or the scope opening brace.

   947 		if (matchCase) {

   948 			return matchCaseAlignment();

   949 		}

   950 

   951 		// the only reliable way to get access specifiers aligned (due to many different styles of using

   952 		// braces in a block) is to go for another access specifier, or the scope opening brace.

   953 		if (matchAccessSpecifier) {

   954 			return matchAccessSpecifierAlignment();

   955 		}

   956 		

   957 		nextToken();

   958 		// Skip access specifiers

   959 		while (fToken == Symbols.TokenCOLON && isAccessSpecifier()) {

   960 			nextToken();

   961 		}

   962 

   963 		int line= fLine;

   964 		switch (fToken) {

   965 		case Symbols.TokenGREATERTHAN:

   966 		case Symbols.TokenRBRACE:

   967 			// skip the block and fall through

   968 			// if we can't complete the scope, reset the scan position

   969 			int pos= fPosition;

   970 			if (!skipScope())

   971 				fPosition= pos;

   972 			return skipToStatementStart(danglingElse, false);

   973 		case Symbols.TokenSEMICOLON:

   974 			// this is the 90% case: after a statement block

   975 			// the end of the previous statement / block previous.end

   976 			// search to the end of the statement / block before the previous;

   977 			// the token just after that is previous.start

   978 			return skipToStatementStart(danglingElse, false);

   979 

   980 		// scope introduction: special treat who special is

   981 		case Symbols.TokenLPAREN:

   982 		case Symbols.TokenLBRACE:

   983 		case Symbols.TokenLBRACKET:

   984 			return handleScopeIntroduction(Math.min(offset + 1, fDocument.getLength()), true);

   985 

   986 		case Symbols.TokenEOF:

   987 			// trap when hitting start of document

   988 			return CHeuristicScanner.NOT_FOUND;

   989 

   990 		case Symbols.TokenEQUAL:

   991 			// indent assignments

   992 			fIndent= fPrefs.prefAssignmentIndent;

   993 			return fPosition;

   994 

   995 		case Symbols.TokenCOLON:

   996 			pos= fPosition;

   997 			if (looksLikeCaseStatement()) {

   998 				fIndent= fPrefs.prefCaseBlockIndent;

   999 				return pos;

  1000 			}

  1001 			fPosition= pos;

  1002 			if (looksLikeTypeInheritanceDecl()) {

  1003 				fIndent= fPrefs.prefBlockIndent;

  1004 				return pos;

  1005 			}

  1006 			fPosition= pos;

  1007 			if (looksLikeConstructorInitializer()) {

  1008 				fIndent= fPrefs.prefBlockIndent;

  1009 				return pos;

  1010 			}

  1011 			fPosition= pos;

  1012 			if (isConditional()) {

  1013 				fPosition= offset;

  1014 				fLine= line;

  1015 				return skipToPreviousListItemOrListStart();

  1016 			}

  1017 			fPosition= pos;

  1018 			return skipToStatementStart(danglingElse, false);

  1019 

  1020 		case Symbols.TokenQUESTIONMARK:

  1021 			if (fPrefs.prefTernaryDeepAlign) {

  1022 				setFirstElementAlignment(fPosition, offset + 1);

  1023 			} else {

  1024 				fIndent= fPrefs.prefTernaryIndent;

  1025 			}

  1026 			return fPosition;

  1027 

  1028 		// indentation for blockless introducers:

  1029 		case Symbols.TokenDO:

  1030 		case Symbols.TokenWHILE:

  1031 		case Symbols.TokenELSE:

  1032 			fIndent= fPrefs.prefSimpleIndent;

  1033 			return fPosition;

  1034 

  1035 		case Symbols.TokenTRY:

  1036 			return skipToStatementStart(danglingElse, false);

  1037 

  1038 		case Symbols.TokenRPAREN:

  1039 			if (skipScope(Symbols.TokenLPAREN, Symbols.TokenRPAREN)) {

  1040 				int scope= fPosition;

  1041 				nextToken();

  1042 				if (fToken == Symbols.TokenIF || fToken == Symbols.TokenWHILE || fToken == Symbols.TokenFOR) {

  1043 					fIndent= fPrefs.prefSimpleIndent;

  1044 					return fPosition;

  1045 				}

  1046 				if (fToken == Symbols.TokenSWITCH) {

  1047 					return fPosition;

  1048 				}

  1049 				fPosition= scope;

  1050 				if (looksLikeMethodDecl()) {

  1051 					return skipToStatementStart(danglingElse, false);

  1052 				}

  1053 				if (fToken == Symbols.TokenCATCH) {

  1054 					return skipToStatementStart(danglingElse, false);

  1055 				}

  1056 				fPosition= scope;

  1057 				if (looksLikeAnonymousTypeDecl()) {

  1058 					return skipToStatementStart(danglingElse, false);

  1059 				}

  1060 			}

  1061 			// restore

  1062 			fPosition= offset;

  1063 			fLine= line;

  1064 			// else: fall through to default

  1065 			return skipToPreviousListItemOrListStart();

  1066 

  1067 		case Symbols.TokenCOMMA:

  1068 			// inside a list of some type

  1069 			// easy if there is already a list item before with its own indentation - we just align

  1070 			// if not: take the start of the list ( LPAREN, LBRACE, LBRACKET ) and either align or

  1071 			// indent by list-indent

  1072 			return skipToPreviousListItemOrListStart();

  1073 		default:

  1074 			// inside whatever we don't know about: similar to the list case:

  1075 			// if we are inside a continued expression, then either align with a previous line that

  1076 			// has indentation or indent from the expression start line (either a scope introducer

  1077 			// or the start of the expression).

  1078 			return skipToPreviousListItemOrListStart();

  1079 		}

  1080 	}

  1081 

  1082 	/**

  1083 	 * Test whether an identifier encountered during scanning is part of

  1084 	 * a type declaration, by scanning backward and ignoring any identifiers, commas,

  1085 	 * and colons until we hit <code>class</code>, <code>struct</code>, <code>union</code>,

  1086 	 * or <code>enum</code>.  If any braces, semicolons, or parentheses are encountered,

  1087 	 * this is not a type declaration.

  1088 	 * @return the reference offset of the start of the statement

  1089 	 */

  1090 	private int matchTypeDeclaration() {

  1091 		while (true) {

  1092 			nextToken();

  1093 			if (fToken == Symbols.TokenIDENT

  1094 					|| fToken == Symbols.TokenCOMMA

  1095 					|| fToken == Symbols.TokenCOLON

  1096 					|| fToken == Symbols.TokenPUBLIC

  1097 					|| fToken == Symbols.TokenPROTECTED

  1098 					|| fToken == Symbols.TokenPRIVATE) {

  1099 				continue;

  1100 			}

  1101 			if (fToken == Symbols.TokenCLASS

  1102 					|| fToken == Symbols.TokenSTRUCT

  1103 					|| fToken == Symbols.TokenUNION

  1104 					|| fToken == Symbols.TokenENUM) {

  1105 				// inside a type declaration?  Only so if not preceded by '(' or ',' as in

  1106 				// a parameter list.  To be safe, only accept ';' or EOF

  1107 				int pos= fPosition;

  1108 				nextToken();

  1109 				if (fToken == Symbols.TokenSEMICOLON || fToken == Symbols.TokenEOF) {

  1110 					return pos;

  1111 				} else {

  1112 					return CHeuristicScanner.NOT_FOUND;

  1113 				}

  1114 			} else {

  1115 				return CHeuristicScanner.NOT_FOUND;

  1116 			}

  1117 		}

  1118 	}

  1119 

  1120 	/**

  1121 	 * Test whether the colon at the current position marks a case statement

  1122 	 * 

  1123 	 * @return <code>true</code> if this looks like a case statement

  1124 	 */

  1125 	private boolean looksLikeCaseStatement() {

  1126 		nextToken();

  1127 		switch (fToken) {

  1128 		case Symbols.TokenCASE:

  1129 			// char literal got skipped

  1130 			return true;

  1131 		case Symbols.TokenIDENT:

  1132 			nextToken();

  1133 			while (skipQualifiers()) {

  1134 				nextToken();