Attachment #46343 for bug #148582

Lines 32-37 Link Here

(-)ui/org/eclipse/cdt/ui/tests/text/CAutoIndentTest.java (-8 / +69 lines)
32	import org.eclipse.jface.text.IDocument;	32	import org.eclipse.jface.text.IDocument;
33	import org.eclipse.jface.text.IRegion;	33	import org.eclipse.jface.text.IRegion;
34	import org.eclipse.jface.text.TextUtilities;	34	import org.eclipse.jface.text.TextUtilities;
		35	import org.eclipse.swt.widgets.Shell;
		36	import org.eclipse.ui.PlatformUI;
35		37
36	/**	38	/**
37	* Testing the auto indent strategies.	39	* Testing the auto indent strategies.
Lines 71-77 Link Here
71	public void type(char c) throws BadLocationException {	73	public void type(char c) throws BadLocationException {
72	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, new String(new char[] { c }));	74	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, new String(new char[] { c }));
73	customizeDocumentCommand(command);	75	customizeDocumentCommand(command);
74	fCaretOffset += command.exec(fDoc);	76	fCaretOffset = command.exec(fDoc);
75	}	77	}
76		78
77	private void customizeDocumentCommand(TestDocumentCommand command) throws BadLocationException {	79	private void customizeDocumentCommand(TestDocumentCommand command) throws BadLocationException {
Lines 94-100 Link Here
94	public void paste(String text) throws BadLocationException {	96	public void paste(String text) throws BadLocationException {
95	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, text);	97	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, text);
96	customizeDocumentCommand(command);	98	customizeDocumentCommand(command);
97	fCaretOffset += command.exec(fDoc);	99	fCaretOffset = command.exec(fDoc);
98	}	100	}
99		101
100	public void paste(int offset, String text) throws BadLocationException {	102	public void paste(int offset, String text) throws BadLocationException {
Lines 110-122 Link Here
110	public void backspace() throws BadLocationException {	112	public void backspace() throws BadLocationException {
111	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset-1, 1, ""); //$NON-NLS-1$	113	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset-1, 1, ""); //$NON-NLS-1$
112	customizeDocumentCommand(command);	114	customizeDocumentCommand(command);
113	fCaretOffset += command.exec(fDoc);	115	fCaretOffset = command.exec(fDoc);
114	}	116	}
115		117
116	public int getCaretOffset() {	118	public int getCaretOffset() {
117	return fCaretOffset;	119	return fCaretOffset;
118	}	120	}
119		121
		122	public int setCaretOffset(int offset) {
		123	fCaretOffset = offset;
		124	if (fCaretOffset < 0)
		125	fCaretOffset = 0;
		126	else if (fCaretOffset > fDoc.getLength())
		127	fCaretOffset = fDoc.getLength();
		128	return fCaretOffset;
		129	}
		130
		131	/**
		132	* Moves caret right or left by the given number of characters.
		133	*
		134	* @param shift Move distance.
		135	* @return New caret offset.
		136	*/
		137	public int moveCaret(int shift) {
		138	return setCaretOffset(fCaretOffset + shift);
		139	}
		140
120	public int getCaretLine() throws BadLocationException {	141	public int getCaretLine() throws BadLocationException {
121	return fDoc.getLineOfOffset(fCaretOffset);	142	return fDoc.getLineOfOffset(fCaretOffset);
122	}	143	}
Lines 167-178 Link Here
167		188
168	owner = null;	189	owner = null;
169	caretOffset = -1;	190	caretOffset = -1;
170
171	}	191	}
172		192
		193	/**
		194	* Returns new caret position.
		195	*/
173	public int exec(IDocument doc) throws BadLocationException {	196	public int exec(IDocument doc) throws BadLocationException {
174	doc.replace(offset, length, text);	197	doc.replace(offset, length, text);
175	return text.length() - length;	198	return caretOffset != -1 ?
		199	caretOffset :
		200	offset + (text == null ? 0 : text.length());
176	}	201	}
177	}	202	}
178		203
Lines 188-199 Link Here
188	return new TestSuite(CAutoIndentTest.class);	213	return new TestSuite(CAutoIndentTest.class);
189	}	214	}
190		215
		216	protected void setUp() throws Exception {
		217	super.setUp();
		218	Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
		219	shell.forceActive();
		220	shell.forceFocus();
		221	}
		222
191	private AutoEditTester createAutoEditTester() {	223	private AutoEditTester createAutoEditTester() {
192	CTextTools textTools = CUIPlugin.getDefault().getTextTools();	224	CTextTools textTools = CUIPlugin.getDefault().getTextTools();
193	IDocument doc = new Document();	225	IDocument doc = new Document();
194	textTools.setupCDocument(doc);	226	textTools.setupCDocument(doc);
195	AutoEditTester tester = new AutoEditTester(doc, textTools.getDocumentPartitioning());	227	AutoEditTester tester = new AutoEditTester(doc, textTools.getDocumentPartitioning());
196	tester.setAutoEditStrategy(IDocument.DEFAULT_CONTENT_TYPE, new CAutoIndentStrategy());	228	tester.setAutoEditStrategy(IDocument.DEFAULT_CONTENT_TYPE,
		229	new CAutoIndentStrategy(textTools.getDocumentPartitioning(), null));
197	tester.setAutoEditStrategy(ICPartitions.C_MULTILINE_COMMENT, new CCommentAutoIndentStrategy());	230	tester.setAutoEditStrategy(ICPartitions.C_MULTILINE_COMMENT, new CCommentAutoIndentStrategy());
198	return tester;	231	return tester;
199	}	232	}
Lines 202-211 Link Here
202	AutoEditTester tester = createAutoEditTester(); //$NON-NLS-1$	235	AutoEditTester tester = createAutoEditTester(); //$NON-NLS-1$
203	tester.type("void main() {\n"); //$NON-NLS-1$	236	tester.type("void main() {\n"); //$NON-NLS-1$
204	assertEquals(1, tester.getCaretLine());	237	assertEquals(1, tester.getCaretLine());
		238	// Nested statement is indented by one.
205	assertEquals(1, tester.getCaretColumn());	239	assertEquals(1, tester.getCaretColumn());
206	tester.type("}\n"); //$NON-NLS-1$	240	// The brace was closed automatically.
		241	assertEquals("}", tester.getLine(1)); //$NON-NLS-1$
		242	tester.type("if (expression1 &&\n"); //$NON-NLS-1$
207	assertEquals(2, tester.getCaretLine());	243	assertEquals(2, tester.getCaretLine());
208	assertEquals(0, tester.getCaretColumn());	244	// Continuation line is indented by two relative to the statement.
		245	assertEquals(3, tester.getCaretColumn());
		246	tester.type("expression2 &&\n"); //$NON-NLS-1$
		247	assertEquals(3, tester.getCaretLine());
		248	// Second continuation line is also indented by two relative to the statement.
		249	assertEquals(3, tester.getCaretColumn());
		250	tester.type("expression3) {"); //$NON-NLS-1$
		251	// Remember caret position.
		252	int offset = tester.getCaretOffset();
		253	// Press Enter
		254	tester.type("\n"); //$NON-NLS-1$
		255	assertEquals(4, tester.getCaretLine());
		256	// Nested statement is indented by one relative to the containing statement.
		257	assertEquals(2, tester.getCaretColumn());
		258	// The brace was closed automatically.
		259	assertEquals("\t}", tester.getLine(1)); //$NON-NLS-1$
		260	tester.type("int x = 5;"); //$NON-NLS-1$
		261	// Move caret back after the opening brace.
		262	tester.setCaretOffset(offset);
		263	// Press Enter
		264	tester.type("\n"); //$NON-NLS-1$
		265	assertEquals(4, tester.getCaretLine());
		266	// Nested statement is indented by one relative to the containing statement.
		267	assertEquals(2, tester.getCaretColumn());
		268	// No auto closing brace since the braces are already balanced.
		269	assertEquals("\t\tint x = 5;", tester.getLine(1)); //$NON-NLS-1$
209	}	270	}
210		271
211	public void testDefaultAutoIndent() throws IOException, CoreException, BadLocationException {	272	public void testDefaultAutoIndent() throws IOException, CoreException, BadLocationException {

Lines 12-20 Link Here

(-)src/org/eclipse/cdt/internal/corext/util/CodeFormatterUtil.java (+79 lines)
12		12
13	import java.util.Map;	13	import java.util.Map;
14		14
		15	import org.eclipse.cdt.core.CCorePlugin;
15	import org.eclipse.cdt.core.ToolFactory;	16	import org.eclipse.cdt.core.ToolFactory;
16	import org.eclipse.cdt.core.formatter.CodeFormatter;	17	import org.eclipse.cdt.core.formatter.CodeFormatter;
		18	import org.eclipse.cdt.core.formatter.CodeFormatterConstants;
		19	import org.eclipse.cdt.core.model.ICProject;
17	import org.eclipse.cdt.ui.CUIPlugin;	20	import org.eclipse.cdt.ui.CUIPlugin;
		21
18	import org.eclipse.core.runtime.Assert;	22	import org.eclipse.core.runtime.Assert;
19	import org.eclipse.jface.preference.IPreferenceStore;	23	import org.eclipse.jface.preference.IPreferenceStore;
20	import org.eclipse.jface.text.BadLocationException;	24	import org.eclipse.jface.text.BadLocationException;
Lines 34-40 Link Here
34	// String str= format(CodeFormatter.K_EXPRESSION, "x", indent, null, "", (Map) null); //$NON-NLS-1$ //$NON-NLS-2$	38	// String str= format(CodeFormatter.K_EXPRESSION, "x", indent, null, "", (Map) null); //$NON-NLS-1$ //$NON-NLS-2$
35	// return str.substring(0, str.indexOf('x'));	39	// return str.substring(0, str.indexOf('x'));
36	// }	40	// }
		41
		42	/**
		43	* Gets the current tab width.
		44	*
		45	* @param project The project where the source is used, used for project
		46	* specific options or <code>null</code> if the project is unknown
		47	* and the workspace default should be used
		48	* @return The tab width
		49	*/
		50	public static int getTabWidth(ICProject project) {
		51	/*
		52	* If the tab-char is SPACE, FORMATTER_INDENTATION_SIZE is not used
		53	* by the core formatter.
		54	* We piggy back the visual tab length setting in that preference in
		55	* that case.
		56	*/
		57	String key;
		58	if (CCorePlugin.SPACE.equals(getCoreOption(project, CodeFormatterConstants.FORMATTER_TAB_CHAR)))
		59	key= CodeFormatterConstants.FORMATTER_INDENTATION_SIZE;
		60	else
		61	key= CodeFormatterConstants.FORMATTER_TAB_SIZE;
37		62
		63	return getCoreOption(project, key, 4);
		64	}
		65
		66	/**
		67	* Returns the current indent width.
		68	*
		69	* @param project the project where the source is used or <code>null</code>
		70	* if the project is unknown and the workspace default should be used
		71	* @return the indent width
		72	*/
		73	public static int getIndentWidth(ICProject project) {
		74	String key;
		75	if (CodeFormatterConstants.MIXED.equals(getCoreOption(project, CodeFormatterConstants.FORMATTER_TAB_CHAR)))
		76	key= CodeFormatterConstants.FORMATTER_INDENTATION_SIZE;
		77	else
		78	key= CodeFormatterConstants.FORMATTER_TAB_SIZE;
		79
		80	return getCoreOption(project, key, 4);
		81	}
		82
		83	/**
		84	* Returns the possibly <code>project</code>-specific core preference
		85	* defined under <code>key</code>.
		86	*
		87	* @param project the project to get the preference from, or
		88	* <code>null</code> to get the global preference
		89	* @param key the key of the preference
		90	* @return the value of the preference
		91	*/
		92	private static String getCoreOption(ICProject project, String key) {
		93	if (project == null)
		94	return CCorePlugin.getOption(key);
		95	return project.getOption(key, true);
		96	}
		97
		98	/**
		99	* Returns the possibly <code>project</code>-specific core preference
		100	* defined under <code>key</code>, or <code>def</code> if the value is
		101	* not a integer.
		102	*
		103	* @param project the project to get the preference from, or
		104	* <code>null</code> to get the global preference
		105	* @param key the key of the preference
		106	* @param def the default value
		107	* @return the value of the preference
		108	*/
		109	private static int getCoreOption(ICProject project, String key, int def) {
		110	try {
		111	return Integer.parseInt(getCoreOption(project, key));
		112	} catch (NumberFormatException e) {
		113	return def;
		114	}
		115	}
		116
38	/**	117	/**
39	* Evaluates the edit on the given string.	118	* Evaluates the edit on the given string.
40	* @throws IllegalArgumentException If the positions are not inside the string, a	119	* @throws IllegalArgumentException If the positions are not inside the string, a




	public static final String EDITOR_TEXT_HOVER_MODIFIER_MASKS= "hoverModifierMasks"; //$NON-NLS-1$

	/**
	 * A named preference that controls whether the 'close strings' feature
	 *  is   enabled.
	 * <p>
	 * Value is of type <code>Boolean</code>.
	 * </p>
	 */
	public final static String EDITOR_CLOSE_STRINGS= "closeStrings"; //$NON-NLS-1$

	/**
	 * A named preference that controls whether the 'wrap strings' feature is
	 * enabled.
	 * <p>
	 * Value is of type <code>Boolean</code>.
	 * </p>
	 */
	public final static String EDITOR_WRAP_STRINGS= "wrapStrings"; //$NON-NLS-1$

	/**
	 * A named preference that controls whether the 'escape strings' feature is
	 * enabled.
	 * <p>
	 * Value is of type <code>Boolean</code>.
	 * </p>
	 */
	public final static String EDITOR_ESCAPE_STRINGS= "escapeStrings"; //$NON-NLS-1$

	/**
	 * A named preference that controls whether the 'close brackets' feature is
	 * enabled.
	 * <p>
	 * Value is of type <code>Boolean</code>.
	 * </p>
	 */
	public final static String EDITOR_CLOSE_BRACKETS= "closeBrackets"; //$NON-NLS-1$

	/**
	 * A named preference that controls whether the 'close braces' feature is
	 * enabled.
	 * <p>
	 * Value is of type <code>Boolean</code>.
	 * </p>
	 */
	public final static String EDITOR_CLOSE_BRACES= "closeBraces"; //$NON-NLS-1$

	/**
	 * The id of the best match hover contributed for extension point
	 * <code>javaEditorTextHovers</code>.
	 *

		store.setDefault(PreferenceConstants.EDITOR_FOLDING_METHODS, false);
		store.setDefault(PreferenceConstants.EDITOR_FOLDING_MACROS, true);

		store.setDefault(PreferenceConstants.EDITOR_CLOSE_STRINGS, true);
		store.setDefault(PreferenceConstants.EDITOR_CLOSE_BRACKETS, true);
		store.setDefault(PreferenceConstants.EDITOR_CLOSE_BRACES, true);
		store.setDefault(PreferenceConstants.EDITOR_WRAP_STRINGS, true);
		store.setDefault(PreferenceConstants.EDITOR_ESCAPE_STRINGS, false);
    }
}




import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.editors.text.TextSourceViewerConfiguration;
import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.ITextEditor;

import org.eclipse.cdt.core.dom.ast.gnu.c.GCCLanguage;
import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;
import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.model.ILanguage;
import org.eclipse.cdt.ui.CElementContentProvider;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.ILanguageUI;

import org.eclipse.cdt.internal.ui.editor.CDocumentProvider;
import org.eclipse.cdt.internal.ui.editor.CEditor;
import org.eclipse.cdt.internal.ui.editor.CElementHyperlinkDetector;
import org.eclipse.cdt.internal.ui.editor.CSourceViewer;

import org.eclipse.cdt.internal.ui.text.contentassist.ContentAssistPreference;



/**
 * Configuration for an <code>SourceViewer</code> which shows C code.
 */

	 * @see org.eclipse.jface.text.source.SourceViewerConfiguration#getAutoEditStrategies(org.eclipse.jface.text.source.ISourceViewer, java.lang.String)
	 */
	public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {
		String partitioning= getConfiguredDocumentPartitioning(sourceViewer);
		if (ICPartitions.C_MULTILINE_COMMENT.equals(contentType))
			return new IAutoEditStrategy[] { new CCommentAutoIndentStrategy() };
//		else if (ICPartitions.C_STRING.equals(contentType))
//			return new IAutoEditStrategy[] { new SmartSemicolonAutoEditStrategy(partitioning), new JavaStringAutoIndentStrategy(partitioning) };
		else
			return new IAutoEditStrategy[] { new CAutoIndentStrategy(partitioning, getProject()) };
	}

	/**

		return (String[]) vector.toArray(new String[vector.size()]);
	}

	private ICProject getProject() {
		ITextEditor editor= getEditor();
		if (editor == null)
			return null;

		ICElement element= null;
		IEditorInput input= editor.getEditorInput();
		IDocumentProvider provider= editor.getDocumentProvider();
		if (provider instanceof CDocumentProvider) {
			CDocumentProvider cudp= (CDocumentProvider) provider;
			element= cudp.getWorkingCopy(input);
		}

		if (element == null)
			return null;

		return element.getCProject();
	}

	/**
	 * @see SourceViewerConfiguration#getAnnotationHover(ISourceViewer)
	 */




 *     IBM Corporation - initial API and implementation
 *     QNX Software System
 *     Anton Leherbauer (Wind River Systems) - Fixed bug 48339
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DefaultIndentLineAutoEditStrategy;
import org.eclipse.jface.text.DocumentCommand;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.texteditor.ITextEditorExtension3;

import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.PreferenceConstants;

/**
 * Auto indent strategy sensitive to brackets.
 */
public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
	private static final String MULTILINE_COMMENT_CLOSE = "*/"; //$NON-NLS-1$
//	private static final GCCScannerExtensionConfiguration C_GNU_SCANNER_EXTENSION = new GCCScannerExtensionConfiguration();

	private static class CompilationUnitInfo {
		char[] buffer;
		int delta;

		CompilationUnitInfo(char[] buffer, int delta) {
			this.buffer = buffer;
			this.delta = delta;
		}
	}

	private boolean fCloseBrace;
	private boolean fIsSmartMode;

	private String fPartitioning;
	private final ICProject fProject;

	/**
	 * Creates a new C auto indent strategy for the given document partitioning.
	 *
	 * @param partitioning the document partitioning
	 * @param project the project to get formatting preferences from, or null to use default preferences
	 */
	public CAutoIndentStrategy(String partitioning, ICProject project) {
		fPartitioning = partitioning;
		fProject = project;
 	}

	// evaluate the line with the opening bracket that matches the closing bracket on the given line
	protected int findMatchingOpenBracket(IDocument d, int line, int end, int closingBracketIncrease) throws BadLocationException {


		int start = d.getLineOffset(line);
		int brackcount = getBracketCount(d, start, end, false) - closingBracketIncrease;


		// sum up the brackets counts of each line (closing brackets count negative, 

			if (line < 0) {
				return -1;
			}
			start = d.getLineOffset(line);
			end = start + d.getLineLength(line) - 1;
			brackcount += getBracketCount(d, start, end, false);
		}
		return line;



	private int getBracketCount(IDocument d, int start, int end, boolean ignoreCloseBrackets) throws BadLocationException {
		int bracketcount = 0;
		while (start < end) {
			char curr = d.getChar(start);
			start++;
			switch (curr) {
				case '/' :
					if (start < end) {
						char next = d.getChar(start);
						if (next == '*') {
							// a comment starts, advance to the comment end
							start = getCommentEnd(d, start + 1, end);
						} else if (next == '/') {
							// '//'-comment: nothing to do anymore on this line 
							start = end;
						}
					}
					break;
				case '*' :
					if (start < end) {
						char next = d.getChar(start);
						if (next == '/') {
							// we have been in a comment: forget what we read before
							bracketcount = 0;
							start++;
						}
					}
					break;
				case '{' :
					bracketcount++;
					ignoreCloseBrackets = false;
					break;
				case '}' :
					if (!ignoreCloseBrackets) {

					break;
				case '"' :
				case '\'' :
					start = getStringEnd(d, start, end, curr);
					break;
				default :
			}


	private int getCommentEnd(IDocument d, int pos, int end) throws BadLocationException {
		while (pos < end) {
			char curr = d.getChar(pos);
			pos++;
			if (curr == '*') {
				if (pos < end && d.getChar(pos) == '/') {


	protected String getIndentOfLine(IDocument d, int line) throws BadLocationException {
		if (line > -1) {
			int start = d.getLineOffset(line);
			int end = start + d.getLineLength(line) - 1;
			int whiteend = findEndOfWhiteSpace(d, start, end);
			return d.get(start, whiteend - start);
		}
		return ""; //$NON-NLS-1$


	private int getStringEnd(IDocument d, int pos, int end, char ch) throws BadLocationException {
		while (pos < end) {
			char curr = d.getChar(pos);
			pos++;
			if (curr == '\\') {
				// ignore escaped characters

			return;

		try {
			int p = (c.offset == d.getLength() ? c.offset - 1 : c.offset);
			int line = d.getLineOfOffset(p);
			int start = d.getLineOffset(line);
			int whiteend = findEndOfWhiteSpace(d, start, c.offset);


			// shift only when line does not contain any text up to the closing bracket
			if (whiteend == c.offset) {
				// evaluate the line with the opening bracket that matches out closing bracket
				int indLine = findMatchingOpenBracket(d, line, c.offset, 1);
				if (indLine != -1 && indLine != line) {
					// take the indent of the found line
					StringBuffer replaceText = new StringBuffer(getIndentOfLine(d, indLine));
					// add the rest of the current line including the just added close bracket
					replaceText.append(d.get(whiteend, c.offset - whiteend));
					replaceText.append(c.text);
					// modify document command
					c.length = c.offset - start;
					c.offset = start;
					c.text = replaceText.toString();
				}
			}
		} catch (BadLocationException excp) {

		}
	}

	private void smartIndentAfterClosingBracket(IDocument d, DocumentCommand c) {
		if (c.offset == -1 || d.getLength() == 0)
		if (c.offset == -1 || docLength == 0)
			return;

		try {
			int p = (c.offset == d.getLength() ? c.offset - 1 : c.offset);
			int line = d.getLineOfOffset(p);
			int start = d.getLineOffset(line);
			int whiteend = findEndOfWhiteSpace(d, start, c.offset);

			CHeuristicScanner scanner = new CHeuristicScanner(d);
			CIndenter indenter = new CIndenter(d, scanner, fProject);

			// shift only when line does not contain any text up to the closing bracket
			if (whiteend == c.offset) {
				// evaluate the line with the opening bracket that matches out closing bracket
				int reference = indenter.findReferencePosition(c.offset, false, true, false, false);
				int indLine = d.getLineOfOffset(reference);
				if (indLine != -1 && indLine != line) {
					// take the indent of the found line
					StringBuffer replaceText = new StringBuffer(getIndentOfLine(d, indLine));
					// add the rest of the current line including the just added close bracket
					replaceText.append(d.get(whiteend, c.offset - whiteend));
					replaceText.append(c.text);
					// modify document command
					c.length += c.offset - start;
					c.offset = start;
					c.text = replaceText.toString();
				}
			}
		} catch (BadLocationException e) {
			CUIPlugin.getDefault().log(e);
		}
	}

	private void smartIndentAfterOpeningBracket(IDocument d, DocumentCommand c) {
		if (c.offset < 1 || d.getLength() == 0)
			return;

		CHeuristicScanner scanner = new CHeuristicScanner(d);

		int p = (c.offset == d.getLength() ? c.offset - 1 : c.offset);

		try {
			// current line
			int line = d.getLineOfOffset(p);
			int lineOffset = d.getLineOffset(line);

			// make sure we don't have any leading comments etc.
			if (d.get(lineOffset, p - lineOffset).trim().length() != 0)
				return;

			// line of last javacode
			int pos = scanner.findNonWhitespaceBackward(p, CHeuristicScanner.UNBOUND);
			if (pos == -1)
				return;
			int lastLine = d.getLineOfOffset(pos);

			// only shift if the last java line is further up and is a braceless block candidate
			if (lastLine < line) {
				CIndenter indenter = new CIndenter(d, scanner, fProject);
				StringBuffer indent = indenter.computeIndentation(p, true);
				String toDelete = d.get(lineOffset, c.offset - lineOffset);
				if (indent != null && !indent.toString().equals(toDelete)) {
					c.text = indent.append(c.text).toString();
					c.length += c.offset - lineOffset;
					c.offset = lineOffset;
				}
			}
			c.text= buf.toString();

		} catch (BadLocationException e) {
			CUIPlugin.getDefault().log(e);
		}
	}

	private void smartIndentAfterNewLine(IDocument d, DocumentCommand c) {
		CHeuristicScanner scanner = new CHeuristicScanner(d);
		CIndenter indenter = new CIndenter(d, scanner, fProject);
		StringBuffer indent = indenter.computeIndentation(c.offset);
		if (indent == null)
			indent = new StringBuffer(); 

		int docLength = d.getLength();
		if (c.offset == -1 || docLength == 0)
			return;

		try {
			int p = (c.offset == docLength ? c.offset - 1 : c.offset);
			int line = d.getLineOfOffset(p);

			StringBuffer buf = new StringBuffer(c.text + indent);

			IRegion reg = d.getLineInformation(line);
			int lineEnd = reg.getOffset() + reg.getLength();

			int contentStart = findEndOfWhiteSpace(d, c.offset, lineEnd);
			c.length =  Math.max(contentStart - c.offset, 0);

			int start = reg.getOffset();

			// insert closing brace on new line after an unclosed opening brace
			if (getBracketCount(d, start, c.offset, true) > 0 && fCloseBrace && !isClosedBrace(d, c.offset, c.length)) {
				c.caretOffset = c.offset + buf.length();
				c.shiftsCaret = false;

				// copy old content of line behind insertion point to new line
				// unless we think we are inserting an anonymous type definition
				if (c.offset == 0 || !(computeAnonymousPosition(d, c.offset - 1, fPartitioning, lineEnd) != -1)) {
					if (lineEnd - contentStart > 0) {
						c.length =  lineEnd - c.offset;
						buf.append(d.get(contentStart, lineEnd - contentStart).toCharArray());
					}
				}

				buf.append(TextUtilities.getDefaultLineDelimiter(d));
				StringBuffer reference = null;
				int nonWS = findEndOfWhiteSpace(d, start, lineEnd);
				if (nonWS < c.offset && d.getChar(nonWS) == '{')
					reference = new StringBuffer(d.get(start, nonWS - start));
				else
					reference = indenter.getReferenceIndentation(c.offset);
				if (reference != null)
					buf.append(reference);
				buf.append('}');
			}
			// insert extra line upon new line between two braces
			else if (c.offset > start && contentStart < lineEnd && d.getChar(contentStart) == '}') {
				int firstCharPos = scanner.findNonWhitespaceBackward(c.offset - 1, start);
				if (firstCharPos != CHeuristicScanner.NOT_FOUND && d.getChar(firstCharPos) == '{') {
					c.caretOffset = c.offset + buf.length();
					c.shiftsCaret = false;

					StringBuffer reference = null;
					int nonWS = findEndOfWhiteSpace(d, start, lineEnd);
					if (nonWS < c.offset && d.getChar(nonWS) == '{')
						reference = new StringBuffer(d.get(start, nonWS - start));
					else
						reference = indenter.getReferenceIndentation(c.offset);

					buf.append(TextUtilities.getDefaultLineDelimiter(d));

					if (reference != null)
						buf.append(reference);
				}
			}
			c.text = buf.toString();

		} catch (BadLocationException e) {
			CUIPlugin.getDefault().log(e);
		}
	}
	
	/**
	 * Computes an insert position for an opening brace if <code>offset</code> maps to a position in
	 * <code>document</code> with a expression in parenthesis that will take a block after the closing parenthesis.
	 *
	 * @param document the document being modified
	 * @param offset the offset of the caret position, relative to the line start.
	 * @param partitioning the document partitioning
	 * @param max the max position
	 * @return an insert position relative to the line start if <code>line</code> contains a parenthesized expression that can be followed by a block, -1 otherwise
	 */
	private static int computeAnonymousPosition(IDocument document, int offset, String partitioning,  int max) {
		// find the opening parenthesis for every closing parenthesis on the current line after offset
		// return the position behind the closing parenthesis if it looks like a method declaration
		// or an expression for an if, while, for, catch statement

		CHeuristicScanner scanner = new CHeuristicScanner(document);
		int pos = offset;
		int length = max;
		int scanTo = scanner.scanForward(pos, length, '}');
		if (scanTo == -1)
			scanTo = length;

		int closingParen = findClosingParenToLeft(scanner, pos) - 1;

		while (true) {
			int startScan = closingParen + 1;
			closingParen = scanner.scanForward(startScan, scanTo, ')');
			if (closingParen == -1)
				break;

			int openingParen = scanner.findOpeningPeer(closingParen - 1, '(', ')');

			// no way an expression at the beginning of the document can mean anything
			if (openingParen < 1)
				break;

			// only select insert positions for parenthesis currently embracing the caret
			if (openingParen > pos)
				continue;
		}

		return -1;
	}

	/**
	 * Finds a closing parenthesis to the left of <code>position</code> in document, where that parenthesis is only
	 * separated by whitespace from <code>position</code>. If no such parenthesis can be found, <code>position</code> is returned.
	 *
	 * @param scanner the java heuristic scanner set up on the document
	 * @param position the first character position in <code>document</code> to be considered
	 * @return the position of a closing parenthesis left to <code>position</code> separated only by whitespace, or <code>position</code> if no parenthesis can be found
	 */
	private static int findClosingParenToLeft(CHeuristicScanner scanner, int position) {
		if (position < 1)
			return position;

		if (scanner.previousToken(position - 1, CHeuristicScanner.UNBOUND) == Symbols.TokenRPAREN)
			return scanner.getPosition() + 1;
		return position;
	}

	private boolean isClosedBrace(IDocument document, int offset, int length) {
		CompilationUnitInfo info = getCompilationUnitForMethod(document, offset, fPartitioning);
		if (info == null)
			return false;

		return getBlockBalance(document, offset, fPartitioning) <= 0;
		//TODO: Use smarter algorithm based on 
//		CodeReader reader = new CodeReader(info.buffer);
//		ICodeReaderFactory fileCreator = CDOM.getInstance().getCodeReaderFactory(CDOM.PARSE_WORKING_COPY_WHENEVER_POSSIBLE);
//		
//		IScanner domScanner = new DOMScanner(reader, new ScannerInfo(), ParserMode.COMPLETE_PARSE,
//				ParserLanguage.C, ParserFactory.createDefaultLogService(),
//				C_GNU_SCANNER_EXTENSION, fileCreator);
//		
//		ISourceCodeParser parser = new GNUCPPSourceParser(
//				domScanner,
//				ParserMode.COMPLETE_PARSE,
//				ParserUtil.getParserLogService(),
//				new GPPParserExtensionConfiguration());
//	
//		IASTTranslationUnit translationUnit = parser.parse();
//		final int relativeOffset = offset - info.delta;
//	    IASTNode node = translationUnit.selectNodeForLocation(reader.getPath(), relativeOffset, length);
//		
//		if (node == null)
//			return false;
//
//		if (node instanceof IASTCompoundStatement) {
//			return getBlockBalance(document, offset, fPartitioning) <= 0;
//		} else if (node instanceof IASTIfStatement) { 
//			IASTIfStatement ifStatement = (IASTIfStatement) node;
//			IASTExpression expression = ifStatement.getConditionExpression();
//			IRegion expressionRegion = createRegion(expression, info.delta);
//			IASTStatement thenStatement = ifStatement.getThenClause();
//			IRegion thenRegion = createRegion(thenStatement, info.delta);
//
//			// Between expression and then statement
//			if (expressionRegion.getOffset() + expressionRegion.getLength() <= offset && offset + length <= thenRegion.getOffset())
//				return thenStatement != null;
//
//			IASTStatement elseStatement = ifStatement.getElseClause();
//			IRegion elseRegion = createRegion(elseStatement, info.delta);
//
//			if (elseStatement != null) {
//				int sourceOffset = thenRegion.getOffset() + thenRegion.getLength();
//				int sourceLength = elseRegion.getOffset() - sourceOffset;
//				CHeuristicScanner scanner = new CHeuristicScanner(new SimpleDocument(info.buffer));
//				int pos = sourceOffset;
//				int id;
//				while ((id = scanner.nextToken(pos, sourceOffset + sourceLength - pos)) != CHeuristicScanner.TokenEOF) {
//					if (id == CHeuristicScanner.TokenELSE) {
//						pos = scanner.getPosition();
//						// Between 'else' token and else statement.
//						return pos <= offset && offset + length < elseRegion.getOffset();
//					}
//				}
//				
//				return true;
//			}
//		} else if (node instanceof IASTForStatement) {
//			IASTExpression expression = ((IASTForStatement) node).getConditionExpression();
//			IRegion expressionRegion = createRegion(expression, info.delta);
//			IASTStatement body = ((IASTForStatement) node).getBody();
//			IRegion bodyRegion = createRegion(body, info.delta);
//
//			// Between expression and body statement
//			if (expressionRegion.getOffset() + expressionRegion.getLength() <= offset && offset + length <= bodyRegion.getOffset()) {
//				return body != null;
//			}
//		} else if (node instanceof IASTWhileStatement) {
//			IASTExpression expression = ((IASTWhileStatement) node).getCondition();
//			IRegion expressionRegion = createRegion(expression, info.delta);
//			IASTStatement body = ((IASTWhileStatement) node).getBody();
//			IRegion bodyRegion = createRegion(body, info.delta);
//
//			// Between expression and body statement
//			if (expressionRegion.getOffset() + expressionRegion.getLength() <= offset && offset + length <= bodyRegion.getOffset()) {
//				return body != null;
//			}
//		} else if (node instanceof IASTDoStatement) {
//			IASTDoStatement doStatement = (IASTDoStatement) node;
//			IRegion doRegion = createRegion(doStatement, info.delta);
//			IASTStatement body = doStatement.getBody();
//			IRegion bodyRegion = createRegion(body, info.delta);
//
//			// Between 'do' and body statement.
//			if (doRegion.getOffset() + doRegion.getLength() <= offset && offset + length <= bodyRegion.getOffset()) {
//				return body != null;
//			}
//		}
//
//		return true;
	}

    private boolean isLineDelimiter(IDocument document, String text) {
		String[] delimiters = document.getLegalLineDelimiters();
		if (delimiters != null)
			return TextUtilities.equals(delimiters, text) > -1;
		return false;
	}

	private void smartIndentOnKeypress(IDocument document, DocumentCommand command) {
		switch (command.text.charAt(0)) {
			case '}':
				smartIndentAfterClosingBracket(document, command);
				break;
			case '{':
				smartIndentAfterOpeningBracket(document, command);
				break;
			case 'e':
				smartIndentUponE(document, command);
				break;
		}
	}

	private void smartIndentUponE(IDocument d, DocumentCommand c) {
		if (c.offset < 4 || d.getLength() == 0)
			return;

		try {
			String content = d.get(c.offset - 3, 3);
			if (content.equals("els")) { //$NON-NLS-1$
				CHeuristicScanner scanner = new CHeuristicScanner(d);
				int p = c.offset - 3;

				// current line
				int line = d.getLineOfOffset(p);
				int lineOffset = d.getLineOffset(line);

				// make sure we don't have any leading comments etc.
				if (d.get(lineOffset, p - lineOffset).trim().length() != 0)
					return;

				// line of last javacode
				int pos = scanner.findNonWhitespaceBackward(p - 1, CHeuristicScanner.UNBOUND);
				if (pos == -1)
					return;
				int lastLine = d.getLineOfOffset(pos);

				// only shift if the last java line is further up and is a braceless block candidate
				if (lastLine < line) {

					CIndenter indenter = new CIndenter(d, scanner, fProject);
					int ref = indenter.findReferencePosition(p, true, false, false, false);
					if (ref == CHeuristicScanner.NOT_FOUND)
						return;
					int refLine = d.getLineOfOffset(ref);
					String indent = getIndentOfLine(d, refLine);

					if (indent != null) {
						c.text = indent.toString() + "else"; //$NON-NLS-1$
						c.length += c.offset - lineOffset;
						c.offset = lineOffset;
					}
				}

				return;
			}

			if (content.equals("cas")) { //$NON-NLS-1$
				CHeuristicScanner scanner = new CHeuristicScanner(d);
				int p = c.offset - 3;

				// current line
				int line = d.getLineOfOffset(p);
				int lineOffset = d.getLineOffset(line);

				// make sure we don't have any leading comments etc.
				if (d.get(lineOffset, p - lineOffset).trim().length() != 0)
					return;

				// line of last javacode
				int pos = scanner.findNonWhitespaceBackward(p - 1, CHeuristicScanner.UNBOUND);
				if (pos == -1)
					return;
				int lastLine = d.getLineOfOffset(pos);

				// only shift if the last java line is further up and is a braceless block candidate
				if (lastLine < line) {

					CIndenter indenter = new CIndenter(d, scanner, fProject);
					int ref = indenter.findReferencePosition(p, false, false, false, true);
					if (ref == CHeuristicScanner.NOT_FOUND)
						return;
					int refLine = d.getLineOfOffset(ref);
					int nextToken = scanner.nextToken(ref, CHeuristicScanner.UNBOUND);
					String indent;
					if (nextToken == Symbols.TokenCASE || nextToken == Symbols.TokenDEFAULT)
						indent = getIndentOfLine(d, refLine);
					else // at the brace of the switch
						indent = indenter.computeIndentation(p).toString();

					if (indent != null) {
						c.text = indent.toString() + "case"; //$NON-NLS-1$
						c.length += c.offset - lineOffset;
						c.offset = lineOffset;
					}
				}

				return;
			}
		} catch (BadLocationException e) {
			CUIPlugin.getDefault().log(e);
		}
	}

	/*
	 * @see org.eclipse.jface.text.IAutoEditStrategy#customizeDocumentCommand(IDocument, DocumentCommand)
	 */
	public void customizeDocumentCommand(IDocument d, DocumentCommand c) {
		if (!c.doit)
			return;

		clearCachedValues();
		if (!fIsSmartMode) {
			super.customizeDocumentCommand(d, c);
			return;
		}

		if (c.length == 0 && c.text != null && isLineDelimiter(d, c.text)) {
			if (isAppendToOpenMultilineComment(d, c)) {
				// special case: multi-line comment at end of document (bug 48339)
				CCommentAutoIndentStrategy.commentIndentAfterNewLine(d, c);
			} else {
				smartIndentAfterNewLine(d, c);
			}
		} else if ("/".equals(c.text) && isAppendToOpenMultilineComment(d, c)) { //$NON-NLS-1$
			smartInsertAfterBracket(d, c);
		}
		else if ("/".equals(c.text) && isAppendToOpenMultilineComment(d, c)) { //$NON-NLS-1$
			// special case: multi-line comment at end of document (bug 48339)
			CCommentAutoIndentStrategy.commentIndentForCommentEnd(d, c);
		} else if (c.text.length() == 1) {
			smartIndentOnKeypress(d, c);
// TODO Support smart paste.
//		} else if (c.text.length() > 1 && getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SMART_PASTE)) {
//			smartPaste(d, c); // no smart backspace for paste
		}
	}
	

		return false;
	}

	private static IPreferenceStore getPreferenceStore() {
		return CUIPlugin.getDefault().getCombinedPreferenceStore();
	}

	private void clearCachedValues() {
        IPreferenceStore preferenceStore = getPreferenceStore();
		fCloseBrace = preferenceStore.getBoolean(PreferenceConstants.EDITOR_CLOSE_BRACES);
		fIsSmartMode = computeSmartMode();
	}

	private boolean computeSmartMode() {
		IWorkbenchPage page = CUIPlugin.getActivePage();
		if (page != null)  {
			IEditorPart part = page.getActiveEditor();
			if (part instanceof ITextEditorExtension3) {
				ITextEditorExtension3 extension = (ITextEditorExtension3) part;
				return extension.getInsertMode() == ITextEditorExtension3.SMART_INSERT;
			}
			if (part == null) {
				// TODO: Remove this if statement once CAutoIndentTest is fixed so that getActiveEditor does not return null.
				return true;
			}
		}
		return false;
	}

	private static CompilationUnitInfo getCompilationUnitForMethod(IDocument document, int offset, String partitioning) {
		try {
			CHeuristicScanner scanner = new CHeuristicScanner(document);

			IRegion sourceRange = scanner.findSurroundingBlock(offset);
			if (sourceRange == null)
				return null;
			String source = document.get(sourceRange.getOffset(), sourceRange.getLength());

			StringBuffer contents = new StringBuffer();
			contents.append("class ____C{void ____m()"); //$NON-NLS-1$
			final int methodOffset = contents.length();
			contents.append(source);
			contents.append("};"); //$NON-NLS-1$

			char[] buffer = contents.toString().toCharArray();
			return new CompilationUnitInfo(buffer, sourceRange.getOffset() - methodOffset);
		} catch (BadLocationException e) {
			CUIPlugin.getDefault().log(e);
		}

		return null;
	}

	/**
	 * Returns the block balance, i.e. zero if the blocks are balanced at
	 * <code>offset</code>, a negative number if there are more closing than opening
	 * braces, and a positive number if there are more opening than closing braces.
	 *
	 * @param document
	 * @param offset
	 * @param partitioning
	 * @return the block balance
	 */
	private static int getBlockBalance(IDocument document, int offset, String partitioning) {
		if (offset < 1)
			return -1;
		if (offset >= document.getLength())
			return 1;

		int begin = offset;
		int end = offset - 1;

		CHeuristicScanner scanner = new CHeuristicScanner(document);

		while (true) {
			begin = scanner.findOpeningPeer(begin - 1, '{', '}');
			end = scanner.findClosingPeer(end + 1, '{', '}');
			if (begin == -1 && end == -1)
				return 0;
			if (begin == -1)
				return -1;
			if (end == -1)
				return 1;
		}
	}

//	private static IRegion createRegion(IASTNode node, int delta) {
//		IASTNodeLocation nodeLocation = node.getNodeLocations()[0];
//		return node == null ? null : new Region(nodeLocation.getNodeOffset() + delta, nodeLocation.getNodeLength());
//	}
}




		}
		
		public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
			String text = command.text;
			if (text == null)
				return;
				
			int index = text.indexOf('\t');
			if (index > -1) {
				StringBuffer buffer = new StringBuffer();
				StringBuffer buffer= new StringBuffer();
				
				fLineTracker.set(command.text);
				int lines = fLineTracker.getNumberOfLines();
				
				try {
					for (int i = 0; i < lines; i++) {
						int offset = fLineTracker.getLineOffset(i);
						int endOffset = offset + fLineTracker.getLineLength(i);
						String line = text.substring(offset, endOffset);
						
						int position= 0;
						if (i == 0) {
							IRegion firstLine = document.getLineInformationOfOffset(command.offset);
							position = command.offset - firstLine.getOffset();	
						}
						
						int length = line.length();
						for (int j = 0; j < length; j++) {
							char c = line.charAt(j);
							if (c == '\t') {
								int oldPosition = position;
								position += insertTabString(buffer, position);
								if (command.caretOffset > command.offset + oldPosition) {
									command.caretOffset += position - oldPosition - 1;
								char c= line.charAt(j);
								if (c == '\t') {
									position += insertTabString(buffer, position);
								} else {
									buffer.append(c);
									++ position;
								}
							} else {
								buffer.append(c);
								++position;
							}
							
						}
					}
						
					command.text = buffer.toString();
						
				} catch (BadLocationException x) {
				}
			}
		}

	}

	/*




/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text;

/**
 * Definition of C partitioning and its partitions.
 */
public interface ICPartitions {

	/**
	 * The identifier of the C partitioning.
	 */
	String C_PARTITIONING= "___c_partitioning";  //$NON-NLS-1$

	/**
	 * The identifier of the single-line end comment partition content type.
	 */
	String C_SINGLE_LINE_COMMENT= "__c_singleline_comment"; //$NON-NLS-1$

	/**
	 * The identifier multi-line comment partition content type.
	 */
	String C_MULTI_LINE_COMMENT= "__c_multiline_comment"; //$NON-NLS-1$

//	/**
//	 * The identifier of the Javadoc partition content type.
//	 */
//	String C_DOC= "__c_javadoc"; //$NON-NLS-1$

	/**
	 * The identifier of the C string partition content type.
	 */
	String C_STRING= "__c_string"; //$NON-NLS-1$

	/**
	 * The identifier of the C character partition content type.
	 */
	String C_CHARACTER= "__c_character";  //$NON-NLS-1$
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import java.util.Arrays;

import org.eclipse.cdt.ui.text.ICPartitions;

import org.eclipse.jface.text.Assert;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.jface.text.TypedRegion;

/**
 * Utility methods for heuristic based C manipulations in an incomplete C source file.
 *
 * <p>An instance holds some internal position in the document and is therefore not threadsafe.</p>
 */
public final class CHeuristicScanner implements Symbols {
	/**
	 * Returned by all methods when the requested position could not be found, or if a
	 * {@link BadLocationException} was thrown while scanning.
	 */
	public static final int NOT_FOUND= -1;

	/**
	 * Special bound parameter that means either -1 (backward scanning) or
	 * <code>fDocument.getLength()</code> (forward scanning).
	 */
	public static final int UNBOUND= -2;


	/* character constants */
	private static final char LBRACE= '{';
	private static final char RBRACE= '}';
	private static final char LPAREN= '(';
	private static final char RPAREN= ')';
	private static final char SEMICOLON= ';';
	private static final char COLON= ':';
	private static final char COMMA= ',';
	private static final char LBRACKET= '[';
	private static final char RBRACKET= ']';
	private static final char QUESTIONMARK= '?';
	private static final char EQUAL= '=';
	private static final char LANGLE= '<';
	private static final char RANGLE= '>';

	/**
	 * Specifies the stop condition, upon which the <code>scanXXX</code> methods will decide whether
	 * to keep scanning or not. This interface may implemented by clients.
	 */
	private static abstract class StopCondition {
		/**
		 * Instructs the scanner to return the current position.
		 *
		 * @param ch the char at the current position
		 * @param position the current position
		 * @param forward the iteration direction
		 * @return <code>true</code> if the stop condition is met.
		 */
		public abstract boolean stop(char ch, int position, boolean forward);

		/**
		 * Asks the condition to return the next position to query. The default
		 * is to return the next/previous position.
		 *
		 * @return the next position to scan
		 */
		public int nextPosition(int position, boolean forward) {
			return forward ? position + 1 : position - 1;
		}
	}

	/**
	 * Stops upon a non-whitespace (as defined by {@link Character#isWhitespace(char)}) character.
	 */
	private static class NonWhitespace extends StopCondition {
		/*
		 * @see org.eclipse.jdt.internal.ui.text.JavaHeuristicScanner.StopCondition#stop(char)
		 */
		public boolean stop(char ch, int position, boolean forward) {
			return !Character.isWhitespace(ch);
		}
	}

	/**
	 * Stops upon a non-whitespace character in the default partition.
	 *
	 * @see NonWhitespace
	 */
	private final class NonWhitespaceDefaultPartition extends NonWhitespace {
		/*
		 * @see org.eclipse.jdt.internal.ui.text.JavaHeuristicScanner.StopCondition#stop(char)
		 */
		public boolean stop(char ch, int position, boolean forward) {
			return super.stop(ch, position, true) && isDefaultPartition(position);
		}

		/*
		 * @see org.eclipse.jdt.internal.ui.text.JavaHeuristicScanner.StopCondition#nextPosition(int, boolean)
		 */
		public int nextPosition(int position, boolean forward) {
			ITypedRegion partition= getPartition(position);
			if (fPartition.equals(partition.getType()))
				return super.nextPosition(position, forward);

			if (forward) {
				int end= partition.getOffset() + partition.getLength();
				if (position < end)
					return end;
			} else {
				int offset= partition.getOffset();
				if (position > offset)
					return offset - 1;
			}
			return super.nextPosition(position, forward);
		}
	}

	/**
	 * Stops upon a non-java identifier (as defined by {@link Character#isJavaIdentifierPart(char)}) character.
	 */
	private static class NonJavaIdentifierPart extends StopCondition {
		/*
		 * @see org.eclipse.jdt.internal.ui.text.JavaHeuristicScanner.StopCondition#stop(char)
		 */
		public boolean stop(char ch, int position, boolean forward) {
			return !Character.isJavaIdentifierPart(ch);
		}
	}

	/**
	 * Stops upon a non-java identifier character in the default partition.
	 *
	 * @see NonJavaIdentifierPart
	 */
	private final class NonJavaIdentifierPartDefaultPartition extends NonJavaIdentifierPart {
		/*
		 * @see org.eclipse.jdt.internal.ui.text.JavaHeuristicScanner.StopCondition#stop(char)
		 */
		public boolean stop(char ch, int position, boolean forward) {
			return super.stop(ch, position, true) || !isDefaultPartition(position);
		}

		/*
		 * @see org.eclipse.jdt.internal.ui.text.JavaHeuristicScanner.StopCondition#nextPosition(int, boolean)
		 */
		public int nextPosition(int position, boolean forward) {
			ITypedRegion partition= getPartition(position);
			if (fPartition.equals(partition.getType()))
				return super.nextPosition(position, forward);

			if (forward) {
				int end= partition.getOffset() + partition.getLength();
				if (position < end)
					return end;
			} else {
				int offset= partition.getOffset();
				if (position > offset)
					return offset - 1;
			}
			return super.nextPosition(position, forward);
		}
	}

	/**
	 * Stops upon a character in the default partition that matches the given character list.
	 */
	private final class CharacterMatch extends StopCondition {
		private final char[] fChars;

		/**
		 * Creates a new instance.
		 * @param ch the single character to match
		 */
		public CharacterMatch(char ch) {
			this(new char[] {ch});
		}

		/**
		 * Creates a new instance.
		 * @param chars the chars to match.
		 */
		public CharacterMatch(char[] chars) {
			Assert.isNotNull(chars);
			Assert.isTrue(chars.length > 0);
			fChars= chars;
			Arrays.sort(chars);
		}

		/*
		 * @see org.eclipse.jdt.internal.ui.text.JavaHeuristicScanner.StopCondition#stop(char, int)
		 */
		public boolean stop(char ch, int position, boolean forward) {
			return Arrays.binarySearch(fChars, ch) >= 0 && isDefaultPartition(position);
		}

		/*
		 * @see org.eclipse.jdt.internal.ui.text.JavaHeuristicScanner.StopCondition#nextPosition(int, boolean)
		 */
		public int nextPosition(int position, boolean forward) {
			ITypedRegion partition= getPartition(position);
			if (fPartition.equals(partition.getType()))
				return super.nextPosition(position, forward);

			if (forward) {
				int end= partition.getOffset() + partition.getLength();
				if (position < end)
					return end;
			} else {
				int offset= partition.getOffset();
				if (position > offset)
					return offset - 1;
			}
			return super.nextPosition(position, forward);
		}
	}

	/** The document being scanned. */
	private final IDocument fDocument;
	/** The partitioning being used for scanning. */
	private final String fPartitioning;
	/** The partition to scan in. */
	private final String fPartition;

	/* internal scan state */

	/** the most recently read character. */
	private char fChar;
	/** the most recently read position. */
	private int fPos;
	/**
	 * The most recently used partition.
	 */
	private ITypedRegion fCachedPartition= new TypedRegion(-1, 0, "__no_partition_at_all"); //$NON-NLS-1$

	/* preset stop conditions */
	private final StopCondition fNonWSDefaultPart= new NonWhitespaceDefaultPartition();
	private final static StopCondition fNonWS= new NonWhitespace();
	private final StopCondition fNonIdent= new NonJavaIdentifierPartDefaultPartition();

	/**
	 * Creates a new instance.
	 *
	 * @param document the document to scan
	 * @param partitioning the partitioning to use for scanning
	 * @param partition the partition to scan in
	 */
	public CHeuristicScanner(IDocument document, String partitioning, String partition) {
		Assert.isLegal(document != null);
		Assert.isLegal(partitioning != null);
		Assert.isLegal(partition != null);
		fDocument= document;
		fPartitioning= partitioning;
		fPartition= partition;
	}

	/**
	 * Calls <code>this(document, IJavaPartitions.JAVA_PARTITIONING, IDocument.DEFAULT_CONTENT_TYPE)</code>.
	 *
	 * @param document the document to scan.
	 */
	public CHeuristicScanner(IDocument document) {
		this(document, ICPartitions.C_PARTITIONING, IDocument.DEFAULT_CONTENT_TYPE);
	}

	/**
	 * Returns the most recent internal scan position.
	 *
	 * @return the most recent internal scan position.
	 */
	public int getPosition() {
		return fPos;
	}

	/**
	 * Returns the next token in forward direction, starting at <code>start</code>, and not extending
	 * further than <code>bound</code>. The return value is one of the constants defined in {@link Symbols}.
	 * After a call, {@link #getPosition()} will return the position just after the scanned token
	 * (i.e. the next position that will be scanned).
	 *
	 * @param start the first character position in the document to consider
	 * @param bound the first position not to consider any more
	 * @return a constant from {@link Symbols} describing the next token
	 */
	public int nextToken(int start, int bound) {
		int pos= scanForward(start, bound, fNonWSDefaultPart);
		if (pos == NOT_FOUND)
			return TokenEOF;

		fPos++;

		switch (fChar) {
			case LBRACE:
				return TokenLBRACE;
			case RBRACE:
				return TokenRBRACE;
			case LBRACKET:
				return TokenLBRACKET;
			case RBRACKET:
				return TokenRBRACKET;
			case LPAREN:
				return TokenLPAREN;
			case RPAREN:
				return TokenRPAREN;
			case SEMICOLON:
				return TokenSEMICOLON;
			case COMMA:
				return TokenCOMMA;
			case QUESTIONMARK:
				return TokenQUESTIONMARK;
			case EQUAL:
				return TokenEQUAL;
			case LANGLE:
				return TokenLESSTHAN;
			case RANGLE:
				return TokenGREATERTHAN;
		}

		// else
		if (Character.isJavaIdentifierPart(fChar)) {
			// assume an identifier or keyword
			int from= pos, to;
			pos= scanForward(pos + 1, bound, fNonIdent);
			if (pos == NOT_FOUND)
				to= bound == UNBOUND ? fDocument.getLength() : bound;
			else
				to= pos;

			String identOrKeyword;
			try {
				identOrKeyword= fDocument.get(from, to - from);
			} catch (BadLocationException e) {
				return TokenEOF;
			}

			return getToken(identOrKeyword);


		} else {
			// operators, number literals etc
			return TokenOTHER;
		}
	}

	/**
	 * Returns the next token in backward direction, starting at <code>start</code>, and not extending
	 * further than <code>bound</code>. The return value is one of the constants defined in {@link Symbols}.
	 * After a call, {@link #getPosition()} will return the position just before the scanned token
	 * starts (i.e. the next position that will be scanned).
	 *
	 * @param start the first character position in the document to consider
	 * @param bound the first position not to consider any more
	 * @return a constant from {@link Symbols} describing the previous token
	 */
	public int previousToken(int start, int bound) {
		int pos= scanBackward(start, bound, fNonWSDefaultPart);
		if (pos == NOT_FOUND)
			return TokenEOF;

		fPos--;

		switch (fChar) {
			case LBRACE:
				return TokenLBRACE;
			case RBRACE:
				return TokenRBRACE;
			case LBRACKET:
				return TokenLBRACKET;
			case RBRACKET:
				return TokenRBRACKET;
			case LPAREN:
				return TokenLPAREN;
			case RPAREN:
				return TokenRPAREN;
			case SEMICOLON:
				return TokenSEMICOLON;
			case COLON:
				return TokenCOLON;
			case COMMA:
				return TokenCOMMA;
			case QUESTIONMARK:
				return TokenQUESTIONMARK;
			case EQUAL:
				return TokenEQUAL;
			case LANGLE:
				return TokenLESSTHAN;
			case RANGLE:
				return TokenGREATERTHAN;
		}

		// else
		if (Character.isJavaIdentifierPart(fChar)) {
			// assume an ident or keyword
			int from, to= pos + 1;
			pos= scanBackward(pos - 1, bound, fNonIdent);
			if (pos == NOT_FOUND)
				from= bound == UNBOUND ? 0 : bound + 1;
			else
				from= pos + 1;

			String identOrKeyword;
			try {
				identOrKeyword= fDocument.get(from, to - from);
			} catch (BadLocationException e) {
				return TokenEOF;
			}

			return getToken(identOrKeyword);


		} else {
			// operators, number literals etc
			return TokenOTHER;
		}

	}

	/**
	 * Returns one of the keyword constants or <code>TokenIDENT</code> for a scanned identifier.
	 *
	 * @param s a scanned identifier
	 * @return one of the constants defined in {@link Symbols}
	 */
	private int getToken(String s) {
		Assert.isNotNull(s);

		switch (s.length()) {
			case 2:
				if ("if".equals(s)) //$NON-NLS-1$
					return TokenIF;
				if ("do".equals(s)) //$NON-NLS-1$
					return TokenDO;
				break;
			case 3:
				if ("for".equals(s)) //$NON-NLS-1$
					return TokenFOR;
				if ("try".equals(s)) //$NON-NLS-1$
					return TokenTRY;
				if ("new".equals(s)) //$NON-NLS-1$
					return TokenNEW;
				break;
			case 4:
				if ("case".equals(s)) //$NON-NLS-1$
					return TokenCASE;
				if ("else".equals(s)) //$NON-NLS-1$
					return TokenELSE;
				if ("enum".equals(s)) //$NON-NLS-1$
					return TokenENUM;
				if ("goto".equals(s)) //$NON-NLS-1$
					return TokenGOTO;
				break;
			case 5:
				if ("break".equals(s)) //$NON-NLS-1$
					return TokenBREAK;
				if ("catch".equals(s)) //$NON-NLS-1$
					return TokenCATCH;
				if ("class".equals(s)) //$NON-NLS-1$
					return TokenCLASS;
				if ("while".equals(s)) //$NON-NLS-1$
					return TokenWHILE;
				break;
			case 6:
				if ("return".equals(s)) //$NON-NLS-1$
					return TokenRETURN;
				if ("static".equals(s)) //$NON-NLS-1$
					return TokenSTATIC;
				if ("switch".equals(s)) //$NON-NLS-1$
					return TokenSWITCH;
				break;
			case 7:
				if ("default".equals(s)) //$NON-NLS-1$
					return TokenDEFAULT;
				break;
		}
		return TokenIDENT;
	}

	/**
	 * Returns the position of the closing peer character (forward search). Any scopes introduced by opening peers
	 * are skipped. All peers accounted for must reside in the default partition.
	 *
	 * <p>Note that <code>start</code> must not point to the opening peer, but to the first
	 * character being searched.</p>
	 *
	 * @param start the start position
	 * @param openingPeer the opening peer character (e.g. '{')
	 * @param closingPeer the closing peer character (e.g. '}')
	 * @return the matching peer character position, or <code>NOT_FOUND</code>
	 */
	public int findClosingPeer(int start, final char openingPeer, final char closingPeer) {
		Assert.isLegal(start >= 0);

		try {
			int depth= 1;
			start -= 1;
			while (true) {
				start= scanForward(start + 1, UNBOUND, new CharacterMatch(new char[] {openingPeer, closingPeer}));
				if (start == NOT_FOUND)
					return NOT_FOUND;

				if (fDocument.getChar(start) == openingPeer)
					depth++;
				else
					depth--;

				if (depth == 0)
					return start;
			}

		} catch (BadLocationException e) {
			return NOT_FOUND;
		}
	}

	/**
	 * Returns the position of the opening peer character (backward search). Any scopes introduced by closing peers
	 * are skipped. All peers accounted for must reside in the default partition.
	 *
	 * <p>Note that <code>start</code> must not point to the closing peer, but to the first
	 * character being searched.</p>
	 *
	 * @param start the start position
	 * @param openingPeer the opening peer character (e.g. '{')
	 * @param closingPeer the closing peer character (e.g. '}')
	 * @return the matching peer character position, or <code>NOT_FOUND</code>
	 */
	public int findOpeningPeer(int start, char openingPeer, char closingPeer) {
		Assert.isLegal(start < fDocument.getLength());

		try {
			int depth= 1;
			start += 1;
			while (true) {
				start= scanBackward(start - 1, UNBOUND, new CharacterMatch(new char[] {openingPeer, closingPeer}));
				if (start == NOT_FOUND)
					return NOT_FOUND;

				if (fDocument.getChar(start) == closingPeer)
					depth++;
				else
					depth--;

				if (depth == 0)
					return start;
			}

		} catch (BadLocationException e) {
			return NOT_FOUND;
		}
	}

	/**
	 * Computes the surrounding block around <code>offset</code>. The search is started at the
	 * beginning of <code>offset</code>, i.e. an opening brace at <code>offset</code> will not be
	 * part of the surrounding block, but a closing brace will.
	 *
	 * @param offset the offset for which the surrounding block is computed
	 * @return a region describing the surrounding block, or <code>null</code> if none can be found
	 */
	public IRegion findSurroundingBlock(int offset) {
		if (offset < 1 || offset >= fDocument.getLength())
			return null;

		int begin= findOpeningPeer(offset - 1, LBRACE, RBRACE);
		int end= findClosingPeer(offset, LBRACE, RBRACE);
		if (begin == NOT_FOUND || end == NOT_FOUND)
			return null;
		return new Region(begin, end + 1 - begin);
	}

	/**
	 * Finds the smallest position in <code>fDocument</code> such that the position is &gt;= <code>position</code>
	 * and &lt; <code>bound</code> and <code>Character.isWhitespace(fDocument.getChar(pos))</code> evaluates to <code>false</code>
	 * and the position is in the default partition.
	 *
	 * @param position the first character position in <code>fDocument</code> to be considered
	 * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &gt; <code>position</code>, or <code>UNBOUND</code>
	 * @return the smallest position of a non-whitespace character in [<code>position</code>, <code>bound</code>) that resides in a C partition, or <code>NOT_FOUND</code> if none can be found
	 */
	public int findNonWhitespaceForward(int position, int bound) {
		return scanForward(position, bound, fNonWSDefaultPart);
	}

	/**
	 * Finds the smallest position in <code>fDocument</code> such that the position is &gt;= <code>position</code>
	 * and &lt; <code>bound</code> and <code>Character.isWhitespace(fDocument.getChar(pos))</code> evaluates to <code>false</code>.
	 *
	 * @param position the first character position in <code>fDocument</code> to be considered
	 * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &gt; <code>position</code>, or <code>UNBOUND</code>
	 * @return the smallest position of a non-whitespace character in [<code>position</code>, <code>bound</code>), or <code>NOT_FOUND</code> if none can be found
	 */
	public int findNonWhitespaceForwardInAnyPartition(int position, int bound) {
		return scanForward(position, bound, fNonWS);
	}

	/**
	 * Finds the highest position in <code>fDocument</code> such that the position is &lt;= <code>position</code>
	 * and &gt; <code>bound</code> and <code>Character.isWhitespace(fDocument.getChar(pos))</code> evaluates to <code>false</code>
	 * and the position is in the default partition.
	 *
	 * @param position the first character position in <code>fDocument</code> to be considered
	 * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &lt; <code>position</code>, or <code>UNBOUND</code>
	 * @return the highest position of a non-whitespace character in (<code>bound</code>, <code>position</code>] that resides in a C partition, or <code>NOT_FOUND</code> if none can be found
	 */
	public int findNonWhitespaceBackward(int position, int bound) {
		return scanBackward(position, bound, fNonWSDefaultPart);
	}

	/**
	 * Finds the lowest position <code>p</code> in <code>fDocument</code> such that <code>start</code> &lt;= p &lt;
	 * <code>bound</code> and <code>condition.stop(fDocument.getChar(p), p)</code> evaluates to <code>true</code>.
	 *
	 * @param start the first character position in <code>fDocument</code> to be considered
	 * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &gt; <code>start</code>, or <code>UNBOUND</code>
	 * @param condition the <code>StopCondition</code> to check
	 * @return the lowest position in [<code>start</code>, <code>bound</code>) for which <code>condition</code> holds, or <code>NOT_FOUND</code> if none can be found
	 */
	public int scanForward(int start, int bound, StopCondition condition) {
		Assert.isLegal(start >= 0);

		if (bound == UNBOUND)
			bound= fDocument.getLength();

		Assert.isLegal(bound <= fDocument.getLength());

		try {
			fPos= start;
			while (fPos < bound) {

				fChar= fDocument.getChar(fPos);
				if (condition.stop(fChar, fPos, true))
					return fPos;

				fPos= condition.nextPosition(fPos, true);
			}
		} catch (BadLocationException e) {
		}
		return NOT_FOUND;
	}


	/**
	 * Finds the lowest position in <code>fDocument</code> such that the position is &gt;= <code>position</code>
	 * and &lt; <code>bound</code> and <code>fDocument.getChar(position) == ch</code> evaluates to <code>true</code>
	 * and the position is in the default partition.
	 *
	 * @param position the first character position in <code>fDocument</code> to be considered
	 * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &gt; <code>position</code>, or <code>UNBOUND</code>
	 * @param ch the <code>char</code> to search for
	 * @return the lowest position of <code>ch</code> in (<code>bound</code>, <code>position</code>] that resides in a C partition, or <code>NOT_FOUND</code> if none can be found
	 */
	public int scanForward(int position, int bound, char ch) {
		return scanForward(position, bound, new CharacterMatch(ch));
	}

	/**
	 * Finds the lowest position in <code>fDocument</code> such that the position is &gt;= <code>position</code>
	 * and &lt; <code>bound</code> and <code>fDocument.getChar(position) == ch</code> evaluates to <code>true</code> for at least one
	 * ch in <code>chars</code> and the position is in the default partition.
	 *
	 * @param position the first character position in <code>fDocument</code> to be considered
	 * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &gt; <code>position</code>, or <code>UNBOUND</code>
	 * @param chars an array of <code>char</code> to search for
	 * @return the lowest position of a non-whitespace character in [<code>position</code>, <code>bound</code>) that resides in a C partition, or <code>NOT_FOUND</code> if none can be found
	 */
	public int scanForward(int position, int bound, char[] chars) {
		return scanForward(position, bound, new CharacterMatch(chars));
	}

	/**
	 * Finds the highest position <code>p</code> in <code>fDocument</code> such that <code>bound</code> &lt; <code>p</code> &lt;= <code>start</code>
	 * and <code>condition.stop(fDocument.getChar(p), p)</code> evaluates to <code>true</code>.
	 *
	 * @param start the first character position in <code>fDocument</code> to be considered
	 * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &lt; <code>start</code>, or <code>UNBOUND</code>
	 * @param condition the <code>StopCondition</code> to check
	 * @return the highest position in (<code>bound</code>, <code>start</code> for which <code>condition</code> holds, or <code>NOT_FOUND</code> if none can be found
	 */
	public int scanBackward(int start, int bound, StopCondition condition) {
		if (bound == UNBOUND)
			bound= -1;

		Assert.isLegal(bound >= -1);
		Assert.isLegal(start < fDocument.getLength() );

		try {
			fPos= start;
			while (fPos > bound) {

				fChar= fDocument.getChar(fPos);
				if (condition.stop(fChar, fPos, false))
					return fPos;

				fPos= condition.nextPosition(fPos, false);
			}
		} catch (BadLocationException e) {
		}
		return NOT_FOUND;
	}

	/**
	 * Finds the highest position in <code>fDocument</code> such that the position is &lt;= <code>position</code>
	 * and &gt; <code>bound</code> and <code>fDocument.getChar(position) == ch</code> evaluates to <code>true</code> for at least one
	 * ch in <code>chars</code> and the position is in the default partition.
	 *
	 * @param position the first character position in <code>fDocument</code> to be considered
	 * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &lt; <code>position</code>, or <code>UNBOUND</code>
	 * @param ch the <code>char</code> to search for
	 * @return the highest position of one element in <code>chars</code> in (<code>bound</code>, <code>position</code>] that resides in a C partition, or <code>NOT_FOUND</code> if none can be found
	 */
	public int scanBackward(int position, int bound, char ch) {
		return scanBackward(position, bound, new CharacterMatch(ch));
	}

	/**
	 * Finds the highest position in <code>fDocument</code> such that the position is &lt;= <code>position</code>
	 * and &gt; <code>bound</code> and <code>fDocument.getChar(position) == ch</code> evaluates to <code>true</code> for at least one
	 * ch in <code>chars</code> and the position is in the default partition.
	 *
	 * @param position the first character position in <code>fDocument</code> to be considered
	 * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &lt; <code>position</code>, or <code>UNBOUND</code>
	 * @param chars an array of <code>char</code> to search for
	 * @return the highest position of one element in <code>chars</code> in (<code>bound</code>, <code>position</code>] that resides in a C partition, or <code>NOT_FOUND</code> if none can be found
	 */
	public int scanBackward(int position, int bound, char[] chars) {
		return scanBackward(position, bound, new CharacterMatch(chars));
	}

	/**
	 * Checks whether <code>position</code> resides in a default (C) partition of <code>fDocument</code>.
	 *
	 * @param position the position to be checked
	 * @return <code>true</code> if <code>position</code> is in the default partition of <code>fDocument</code>, <code>false</code> otherwise
	 */
	public boolean isDefaultPartition(int position) {
		return fPartition.equals(getPartition(position).getType());
	}

	/**
	 * Returns the partition at <code>position</code>.
	 *
	 * @param position the position to get the partition for
	 * @return the partition at <code>position</code> or a dummy zero-length
	 *         partition if accessing the document fails
	 */
	private ITypedRegion getPartition(int position) {
		if (!contains(fCachedPartition, position)) {
			Assert.isTrue(position >= 0);
			Assert.isTrue(position <= fDocument.getLength());
			
			try {
				fCachedPartition= TextUtilities.getPartition(fDocument, fPartitioning, position, false);
			} catch (BadLocationException e) {
				fCachedPartition= new TypedRegion(position, 0, "__no_partition_at_all"); //$NON-NLS-1$
			}
		}

		return fCachedPartition;
	}

	/**
	 * Returns <code>true</code> if <code>region</code> contains <code>position</code>.
	 * 
	 * @param region a region
	 * @param position an offset
	 * @return <code>true</code> if <code>region</code> contains <code>position</code>
	 */
	private boolean contains(IRegion region, int position) {
		int offset= region.getOffset();
		return offset <= position && position < offset + region.getLength();
	}

	/**
	 * Checks if the line seems to be an open condition not followed by a block (i.e. an if, while,
	 * or for statement with just one following statement, see example below).
	 *
	 * <pre>
	 * if (condition)
	 *     doStuff();
	 * </pre>
	 *
	 * <p>Algorithm: if the last non-WS, non-Comment code on the line is an if (condition), while (condition),
	 * for( expression), do, else, and there is no statement after that </p>
	 *
	 * @param position the insert position of the new character
	 * @param bound the lowest position to consider
	 * @return <code>true</code> if the code is a conditional statement or loop without a block, <code>false</code> otherwise
	 */
	public boolean isBracelessBlockStart(int position, int bound) {
		if (position < 1)
			return false;

		switch (previousToken(position, bound)) {
			case TokenDO:
			case TokenELSE:
				return true;
			case TokenRPAREN:
				position= findOpeningPeer(fPos, LPAREN, RPAREN);
				if (position > 0) {
					switch (previousToken(position - 1, bound)) {
						case TokenIF:
						case TokenFOR:
						case TokenWHILE:
							return true;
					}
				}
		}

		return false;
	}
	
	/**
	 * Returns <code>true</code> if the document, when scanned backwards from <code>start</code>
	 * appears to contain a class instance creation, i.e. a possibly qualified name preceded by a
	 * <code>new</code> keyword. The <code>start</code> must be at the end of the type name, and
	 * before any generic signature or constructor parameter list. The heuristic will return
	 * <code>true</code> if <code>start</code> is at the following positions (|):
	 * 
	 * <pre>
	 *  new java.util. ArrayList|&lt;String&gt;(10)
	 *  new ArrayList |(10)
	 *  new  / * comment  * / ArrayList |(10)
	 * </pre>
	 * 
	 * but not the following:
	 * 
	 * <pre>
	 *  new java.util. ArrayList&lt;String&gt;(10)|
	 *  new java.util. ArrayList&lt;String&gt;|(10)
	 *  new ArrayList (10)|
	 *  ArrayList |(10)
	 * </pre>
	 * 
	 * @param start the position where the type name of the class instance creation supposedly ends
	 * @param bound the first position in <code>fDocument</code> to not consider any more, with
	 *        <code>bound</code> &lt; <code>start</code>, or <code>UNBOUND</code>
	 * @return <code>true</code> if the current position looks like after the type name of a class
	 *         instance creation
	 */
	public boolean looksLikeClassInstanceCreationBackward(int start, int bound) {
		int token= previousToken(start - 1, bound);
		if (token == Symbols.TokenIDENT) { // type name
			token= previousToken(getPosition(), bound);
			while (token == Symbols.TokenOTHER) { // dot of qualification
				token= previousToken(getPosition(), bound);
				if (token != Symbols.TokenIDENT) // qualification name
					return false;
				token= previousToken(getPosition(), bound);
			}
			return token == Symbols.TokenNEW;
		}
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import java.text.CharacterIterator;

import org.eclipse.jface.text.Assert;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;


/**
 * An <code>IDocument</code> based implementation of
 * <code>CharacterIterator</code> and <code>CharSequence</code>. Note that
 * the supplied document is not copied; if the document is modified during the
 * lifetime of a <code>DocumentCharacterIterator</code>, the methods
 * returning document content may not always return the same values. Also, if
 * accessing the document fails with a {@link BadLocationException}, any of
 * <code>CharacterIterator</code> methods as well as <code>charAt</code>may
 * return {@link CharacterIterator#DONE}.
 */
public class DocumentCharacterIterator implements CharacterIterator, CharSequence {

	private int fIndex= -1;
	private final IDocument fDocument;
	private final int fFirst;
	private final int fLast;

	private void invariant() {
		Assert.isTrue(fIndex >= fFirst);
		Assert.isTrue(fIndex <= fLast);
	}

	/**
	 * Creates an iterator for the entire document.
	 *
	 * @param document the document backing this iterator
	 */
	public DocumentCharacterIterator(IDocument document) {
		this(document, 0);
	}

	/**
	 * Creates an iterator, starting at offset <code>first</code>.
	 *
	 * @param document the document backing this iterator
	 * @param first the first character to consider
	 * @throws IllegalArgumentException if the indices are out of bounds
	 */
	public DocumentCharacterIterator(IDocument document, int first) throws IllegalArgumentException {
		this(document, first, document.getLength());
	}

	/**
	 * Creates an iterator for the document contents from <code>first</code>
	 * (inclusive) to <code>last</code> (exclusive).
	 *
	 * @param document the document backing this iterator
	 * @param first the first character to consider
	 * @param last the last character index to consider
	 * @throws IllegalArgumentException if the indices are out of bounds
	 */
	public DocumentCharacterIterator(IDocument document, int first, int last) throws IllegalArgumentException {
		if (document == null)
			throw new NullPointerException();
		if (first < 0 || first > last)
			throw new IllegalArgumentException();
		if (last > document.getLength())
			throw new IllegalArgumentException();
		fDocument= document;
		fFirst= first;
		fLast= last;
		fIndex= first;
		invariant();
	}

	/*
	 * @see java.text.CharacterIterator#first()
	 */
	public char first() {
		return setIndex(getBeginIndex());
	}

	/*
	 * @see java.text.CharacterIterator#last()
	 */
	public char last() {
		if (fFirst == fLast)
			return setIndex(getEndIndex());
		else
			return setIndex(getEndIndex() - 1);
	}

	/*
	 * @see java.text.CharacterIterator#current()
	 */
	public char current() {
		if (fIndex >= fFirst && fIndex < fLast)
			try {
				return fDocument.getChar(fIndex);
			} catch (BadLocationException e) {
				// ignore
			}
		return DONE;
	}

	/*
	 * @see java.text.CharacterIterator#next()
	 */
	public char next() {
		return setIndex(Math.min(fIndex + 1, getEndIndex()));
	}

	/*
	 * @see java.text.CharacterIterator#previous()
	 */
	public char previous() {
		if (fIndex > getBeginIndex()) {
			return setIndex(fIndex - 1);
		} else {
			return DONE;
		}
	}

	/*
	 * @see java.text.CharacterIterator#setIndex(int)
	 */
	public char setIndex(int position) {
		if (position >= getBeginIndex() && position <= getEndIndex())
			fIndex= position;
		else
			throw new IllegalArgumentException();

		invariant();
		return current();
	}

	/*
	 * @see java.text.CharacterIterator#getBeginIndex()
	 */
	public int getBeginIndex() {
		return fFirst;
	}

	/*
	 * @see java.text.CharacterIterator#getEndIndex()
	 */
	public int getEndIndex() {
		return fLast;
	}

	/*
	 * @see java.text.CharacterIterator#getIndex()
	 */
	public int getIndex() {
		return fIndex;
	}

	/*
	 * @see java.text.CharacterIterator#clone()
	 */
	public Object clone() {
		try {
			return super.clone();
		} catch (CloneNotSupportedException e) {
			throw new InternalError();
		}
	}

	/*
	 * @see java.lang.CharSequence#length()
	 */
	public int length() {
		return getEndIndex() - getBeginIndex();
	}

	/**
	 * {@inheritDoc}
	 * <p>
	 * Note that, if the document is modified concurrently, this method may
	 * return {@link CharacterIterator#DONE} if a {@link BadLocationException}
	 * was thrown when accessing the backing document.
	 * </p>
	 *
	 * @param index {@inheritDoc}
	 * @return {@inheritDoc}
	 */
	public char charAt(int index) {
		if (index >= 0 && index < length())
			try {
				return fDocument.getChar(getBeginIndex() + index);
			} catch (BadLocationException e) {
				// ignore and return DONE
				return DONE;
			}
		else
			throw new IndexOutOfBoundsException();
	}

	/*
	 * @see java.lang.CharSequence#subSequence(int, int)
	 */
	public CharSequence subSequence(int start, int end) {
		if (start < 0)
			throw new IndexOutOfBoundsException();
		if (end < start)
			throw new IndexOutOfBoundsException();
		if (end > length())
			throw new IndexOutOfBoundsException();
		return new DocumentCharacterIterator(fDocument, getBeginIndex() + start, getBeginIndex() + end);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

/**
 * Symbols for the heuristic C/C++ scanner.
 */
public interface Symbols {
	int TokenEOF= -1;
	int TokenLBRACE= 1;
	int TokenRBRACE= 2;
	int TokenLBRACKET= 3;
	int TokenRBRACKET= 4;
	int TokenLPAREN= 5;
	int TokenRPAREN= 6;
	int TokenSEMICOLON= 7;
	int TokenOTHER= 8;
	int TokenCOLON= 9;
	int TokenQUESTIONMARK= 10;
	int TokenCOMMA= 11;
	int TokenEQUAL= 12;
	int TokenLESSTHAN= 13;
	int TokenGREATERTHAN= 14;
	int TokenIF= 109;
	int TokenDO= 1010;
	int TokenFOR= 1011;
	int TokenTRY= 1012;
	int TokenCASE= 1013;
	int TokenELSE= 1014;
	int TokenBREAK= 1015;
	int TokenCATCH= 1016;
	int TokenWHILE= 1017;
	int TokenRETURN= 1018;
	int TokenSTATIC= 1019;
	int TokenSWITCH= 1020;
//	int TokenFINALLY= 1021;
//	int TokenSYNCHRONIZED= 1022;
	int TokenGOTO= 1023;
	int TokenDEFAULT= 1024;
	int TokenNEW= 1025;
	int TokenCLASS= 1026;
//	int TokenINTERFACE= 1027;
	int TokenENUM= 1028;
	int TokenIDENT= 2000;
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.formatter.CodeFormatterConstants;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.internal.corext.util.CodeFormatterUtil;

import org.eclipse.jface.text.Assert;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;


/**
 * Uses the {@link org.eclipse.cdt.internal.ui.text.CHeuristicScanner} to
 * get the indentation level for a certain position in a document.
 *
 * <p>
 * An instance holds some internal position in the document and is therefore
 * not threadsafe.
 * </p>
 */
public final class CIndenter {
	
	/**
	 * The CDT Core preferences.
	 */
	private final class CorePrefs {
		final boolean prefUseTabs;
		final int prefTabSize;
		final int prefIndentationSize;
		final boolean prefArrayDimensionsDeepIndent;
		final int prefArrayIndent;
		final boolean prefArrayDeepIndent;
		final boolean prefTernaryDeepAlign;
		final int prefTernaryIndent;
		final int prefCaseIndent;
		final int prefAssignmentIndent;
		final int prefCaseBlockIndent;
		final int prefSimpleIndent;
		final int prefBracketIndent;
		final boolean prefMethodDeclDeepIndent;
		final int prefMethodDeclIndent;
		final boolean prefMethodCallDeepIndent;
		final int prefMethodCallIndent;
		final boolean prefParenthesisDeepIndent;
		final int prefParenthesisIndent;
		final int prefBlockIndent;
		final int prefMethodBodyIndent;
		final int prefTypeIndent;
		final boolean prefIndentBracesForBlocks;
		final boolean prefIndentBracesForArrays;
		final boolean prefIndentBracesForMethods;
		final boolean prefIndentBracesForTypes;
		final int prefContinuationIndent;
		final boolean prefHasGenerics;
		final String prefTabChar;
		
		private final ICProject fProject;

		/**
		 * Returns the possibly project-specific core preference defined under <code>key</code>.
		 *
		 * @param key the key of the preference
		 * @return the value of the preference
		 */
		private String getCoreFormatterOption(String key) {
			if (fProject == null)
				return CCorePlugin.getOption(key);
			return fProject.getOption(key, true);
		}
		
		CorePrefs(ICProject project) {
			fProject= project;
			prefUseTabs= prefUseTabs();
			prefTabSize= prefTabSize();
			prefIndentationSize= prefIndentationSize();
			prefArrayDimensionsDeepIndent= prefArrayDimensionsDeepIndent();
			prefContinuationIndent= prefContinuationIndent();
			prefBlockIndent= prefBlockIndent();
			prefArrayIndent= prefArrayIndent();
			prefArrayDeepIndent= prefArrayDeepIndent();
			prefTernaryDeepAlign= prefTernaryDeepAlign();
			prefTernaryIndent= prefTernaryIndent();
			prefCaseIndent= prefCaseIndent();
			prefAssignmentIndent= prefAssignmentIndent();
			prefCaseBlockIndent= prefCaseBlockIndent();
			prefIndentBracesForBlocks= prefIndentBracesForBlocks();
			prefSimpleIndent= prefSimpleIndent();
			prefBracketIndent= prefBracketIndent();
			prefMethodDeclDeepIndent= prefMethodDeclDeepIndent();
			prefMethodDeclIndent= prefMethodDeclIndent();
			prefMethodCallDeepIndent= prefMethodCallDeepIndent();
			prefMethodCallIndent= prefMethodCallIndent();
			prefParenthesisDeepIndent= prefParenthesisDeepIndent();
			prefParenthesisIndent= prefParenthesisIndent();
			prefMethodBodyIndent= prefMethodBodyIndent();
			prefTypeIndent= prefTypeIndent();
			prefIndentBracesForArrays= prefIndentBracesForArrays();
			prefIndentBracesForMethods= prefIndentBracesForMethods();
			prefIndentBracesForTypes= prefIndentBracesForTypes();
			prefHasGenerics= hasGenerics();
			prefTabChar= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_TAB_CHAR);
		}
		
		private boolean prefUseTabs() {
			return !CCorePlugin.SPACE.equals(getCoreFormatterOption(CodeFormatterConstants.FORMATTER_TAB_CHAR));
		}

		private int prefTabSize() {
			return CodeFormatterUtil.getTabWidth(fProject);
		}

		private int prefIndentationSize() {
			return CodeFormatterUtil.getIndentWidth(fProject);
		}

		private boolean prefArrayDimensionsDeepIndent() {
			return true; // sensible default, no formatter setting
		}

		private int prefArrayIndent() {
			String option= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER);
			try {
				if (CodeFormatterConstants.getIndentStyle(option) == CodeFormatterConstants.INDENT_BY_ONE)
					return 1;
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}

			return prefContinuationIndent(); // default
		}

		private boolean prefArrayDeepIndent() {
			String option= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER);
			try {
				return CodeFormatterConstants.getIndentStyle(option) == CodeFormatterConstants.INDENT_ON_COLUMN;
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}

			return true;
		}

		private boolean prefTernaryDeepAlign() {
			String option= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION);
			try {
				return CodeFormatterConstants.getIndentStyle(option) == CodeFormatterConstants.INDENT_ON_COLUMN;
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}
			return false;
		}

		private int prefTernaryIndent() {
			String option= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION);
			try {
				if (CodeFormatterConstants.getIndentStyle(option) == CodeFormatterConstants.INDENT_BY_ONE)
					return 1;
				else
					return prefContinuationIndent();
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}

			return prefContinuationIndent();
		}

		private int prefCaseIndent() {
			if (CodeFormatterConstants.TRUE.equals(getCoreFormatterOption(CodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH)))
				return prefBlockIndent();
			else
				return 0;
		}

		private int prefAssignmentIndent() {
			return prefBlockIndent();
		}

		private int prefCaseBlockIndent() {
			if (true)
				return prefBlockIndent();

			if (CodeFormatterConstants.TRUE.equals(getCoreFormatterOption(CodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES)))
				return prefBlockIndent();
			else
				return 0;
		}

		private int prefSimpleIndent() {
			if (prefIndentBracesForBlocks() && prefBlockIndent() == 0)
				return 1;
			else return prefBlockIndent();
		}

		private int prefBracketIndent() {
			return prefBlockIndent();
		}

		private boolean prefMethodDeclDeepIndent() {
			String option= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION);
			try {
				return CodeFormatterConstants.getIndentStyle(option) == CodeFormatterConstants.INDENT_ON_COLUMN;
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}

			return true;
		}

		private int prefMethodDeclIndent() {
			String option= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION);
			try {
				if (CodeFormatterConstants.getIndentStyle(option) == CodeFormatterConstants.INDENT_BY_ONE)
					return 1;
				else
					return prefContinuationIndent();
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}
			return 1;
		}

		private boolean prefMethodCallDeepIndent() {
			String option= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION);
			try {
				return CodeFormatterConstants.getIndentStyle(option) == CodeFormatterConstants.INDENT_ON_COLUMN;
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}
			return false; // sensible default
		}

		private int prefMethodCallIndent() {
			String option= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION);
			try {
				if (CodeFormatterConstants.getIndentStyle(option) == CodeFormatterConstants.INDENT_BY_ONE)
					return 1;
				else
					return prefContinuationIndent();
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}

			return 1; // sensible default
		}

		private boolean prefParenthesisDeepIndent() {
			if (true) // don't do parenthesis deep indentation
				return false;

			String option= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION);
			try {
				return CodeFormatterConstants.getIndentStyle(option) == CodeFormatterConstants.INDENT_ON_COLUMN;
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}

			return false; // sensible default
		}

		private int prefParenthesisIndent() {
			return prefContinuationIndent();
		}

		private int prefBlockIndent() {
			String option= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK);
			if (CodeFormatterConstants.FALSE.equals(option))
				return 0;

			return 1; // sensible default
		}

		private int prefMethodBodyIndent() {
			if (CodeFormatterConstants.FALSE.equals(getCoreFormatterOption(CodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY)))
				return 0;

			return 1; // sensible default
		}

		private int prefTypeIndent() {
			String option= getCoreFormatterOption(CodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_TYPE_HEADER);
			if (CodeFormatterConstants.FALSE.equals(option))
				return 0;

			return 1; // sensible default
		}

		private boolean prefIndentBracesForBlocks() {
			return CodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK));
		}

		private boolean prefIndentBracesForArrays() {
			return CodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER));
		}

		private boolean prefIndentBracesForMethods() {
			return CodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION));
		}

		private boolean prefIndentBracesForTypes() {
			return CodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION));
		}

		private int prefContinuationIndent() {
			try {
				return Integer.parseInt(getCoreFormatterOption(CodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION));
			} catch (NumberFormatException e) {
				// ignore and return default
			}

			return 2; // sensible default
		}
		private boolean hasGenerics() {
			return true;
		}
	}

	/** The document being scanned. */
	private final IDocument fDocument;
	/** The indentation accumulated by <code>findReferencePosition</code>. */
	private int fIndent;
	/**
	 * The absolute (character-counted) indentation offset for special cases
	 * (method defs, array initializers)
	 */
	private int fAlign;
	/** The stateful scanposition for the indentation methods. */
	private int fPosition;
	/** The previous position. */
	private int fPreviousPos;
	/** The most recent token. */
	private int fToken;
	/** The line of <code>fPosition</code>. */
	private int fLine;
	/**
	 * The scanner we will use to scan the document. It has to be installed
	 * on the same document as the one we get.
	 */
	private final CHeuristicScanner fScanner;
	/**
	 * The CDT Core preferences.
	 */
	private final CorePrefs fPrefs;

	/**
	 * Creates a new instance.
	 *
	 * @param document the document to scan
	 * @param scanner the {@link CHeuristicScanner} to be used for scanning
	 * the document. It must be installed on the same <code>IDocument</code>.
	 */
	public CIndenter(IDocument document, CHeuristicScanner scanner) {
		this(document, scanner, null);
	}

	/**
	 * Creates a new instance.
	 *
	 * @param document the document to scan
	 * @param scanner the {@link CHeuristicScanner} to be used for scanning
	 *        the document. It must be installed on the same
	 *        <code>IDocument</code>.
	 * @param project the C/C++ project to get the formatter preferences from, or
	 *        <code>null</code> to use the workspace settings
	 */
	public CIndenter(IDocument document, CHeuristicScanner scanner, ICProject project) {
		Assert.isNotNull(document);
		Assert.isNotNull(scanner);
		fDocument= document;
		fScanner= scanner;
		fPrefs= new CorePrefs(project);
	}

	/**
	 * Computes the indentation at the reference point of <code>position</code>.
	 *
	 * @param offset the offset in the document
	 * @return a String which reflects the indentation at the line in which the
	 *         reference position to <code>offset</code> resides, or <code>null</code>
	 *         if it cannot be determined
	 */
	public StringBuffer getReferenceIndentation(int offset) {
		return getReferenceIndentation(offset, false);
	}

	/**
	 * Computes the indentation at the reference point of <code>position</code>.
	 *
	 * @param offset the offset in the document
	 * @param assumeOpeningBrace <code>true</code> if an opening brace should be assumed
	 * @return a String which reflects the indentation at the line in which the
	 *         reference position to <code>offset</code> resides, or <code>null</code>
	 *         if it cannot be determined
	 */
	private StringBuffer getReferenceIndentation(int offset, boolean assumeOpeningBrace) {

		int unit;
		if (assumeOpeningBrace)
			unit= findReferencePosition(offset, Symbols.TokenLBRACE);
		else
			unit= findReferencePosition(offset, peekChar(offset));

		// if we were unable to find anything, return null
		if (unit == CHeuristicScanner.NOT_FOUND)
			return null;

		return getLeadingWhitespace(unit);

	}

	/**
	 * Computes the indentation at <code>offset</code>.
	 *
	 * @param offset the offset in the document
	 * @return a String which reflects the correct indentation for the line in
	 *         which offset resides, or <code>null</code> if it cannot be
	 *         determined
	 */
	public StringBuffer computeIndentation(int offset) {
		return computeIndentation(offset, false);
	}

	/**
	 * Computes the indentation at <code>offset</code>.
	 *
	 * @param offset the offset in the document
	 * @param assumeOpeningBrace <code>true</code> if an opening brace should be assumed
	 * @return a String which reflects the correct indentation for the line in
	 *         which offset resides, or <code>null</code> if it cannot be
	 *         determined
	 */
	public StringBuffer computeIndentation(int offset, boolean assumeOpeningBrace) {

		StringBuffer reference= getReferenceIndentation(offset, assumeOpeningBrace);

		// handle special alignment
		if (fAlign != CHeuristicScanner.NOT_FOUND) {
			try {
				// a special case has been detected.
				IRegion line= fDocument.getLineInformationOfOffset(fAlign);
				int lineOffset= line.getOffset();
				return createIndent(lineOffset, fAlign, false);
			} catch (BadLocationException e) {
				return null;
			}
		}

		if (reference == null)
			return null;

		// add additional indent
		return createReusingIndent(reference, fIndent);
	}

	/**
	 * Computes the length of a <code>CharacterSequence</code>, counting
	 * a tab character as the size until the next tab stop and every other
	 * character as one.
	 *
	 * @param indent the string to measure
	 * @return the visual length in characters
	 */
	private int computeVisualLength(CharSequence indent) {
		final int tabSize= fPrefs.prefTabSize;
		int length= 0;
		for (int i= 0; i < indent.length(); i++) {
			char ch= indent.charAt(i);
			switch (ch) {
				case '\t':
					if (tabSize > 0) {
						int reminder= length % tabSize;
						length += tabSize - reminder;
					}
					break;
				case ' ':
					length++;
					break;
			}
		}
		return length;
	}

	/**
	 * Strips any characters off the end of <code>reference</code> that exceed
	 * <code>indentLength</code>.
	 *
	 * @param reference the string to measure
	 * @param indentLength the maximum visual indentation length
	 * @return the stripped <code>reference</code>
	 */
	private StringBuffer stripExceedingChars(StringBuffer reference, int indentLength) {
		final int tabSize= fPrefs.prefTabSize;
		int measured= 0;
		int chars= reference.length();
		int i= 0;
		for (; measured < indentLength && i < chars; i++) {
			char ch= reference.charAt(i);
			switch (ch) {
				case '\t':
					if (tabSize > 0) {
						int reminder= measured % tabSize;
						measured += tabSize - reminder;
					}
					break;
				case ' ':
					measured++;
					break;
			}
		}
		int deleteFrom= measured > indentLength ? i - 1 : i;

		return reference.delete(deleteFrom, chars);
	}

	/**
	 * Returns the indentation of the line at <code>offset</code> as a
	 * <code>StringBuffer</code>. If the offset is not valid, the empty string
	 * is returned.
	 *
	 * @param offset the offset in the document
	 * @return the indentation (leading whitespace) of the line in which
	 * 		   <code>offset</code> is located
	 */
	private StringBuffer getLeadingWhitespace(int offset) {
		StringBuffer indent= new StringBuffer();
		try {
			IRegion line= fDocument.getLineInformationOfOffset(offset);
			int lineOffset= line.getOffset();
			int nonWS= fScanner.findNonWhitespaceForwardInAnyPartition(lineOffset, lineOffset + line.getLength());
			indent.append(fDocument.get(lineOffset, nonWS - lineOffset));
			return indent;
		} catch (BadLocationException e) {
			return indent;
		}
	}

	/**
	 * Creates an indentation string of the length indent - start, consisting of
	 * the content in <code>fDocument</code> in the range [start, indent),
	 * with every character replaced by a space except for tabs, which are kept
	 * as such.
	 * <p>
	 * If <code>convertSpaceRunsToTabs</code> is <code>true</code>, every
	 * run of the number of spaces that make up a tab are replaced by a tab
	 * character. If it is not set, no conversion takes place, but tabs in the
	 * original range are still copied verbatim.
	 * </p>
	 *
	 * @param start the start of the document region to copy the indent from
	 * @param indent the exclusive end of the document region to copy the indent
	 *        from
	 * @param convertSpaceRunsToTabs whether to convert consecutive runs of
	 *        spaces to tabs
	 * @return the indentation corresponding to the document content specified
	 *         by <code>start</code> and <code>indent</code>
	 */
	private StringBuffer createIndent(int start, final int indent, final boolean convertSpaceRunsToTabs) {
		final boolean convertTabs= fPrefs.prefUseTabs && convertSpaceRunsToTabs;
		final int tabLen= fPrefs.prefTabSize;
		final StringBuffer ret= new StringBuffer();
		try {
			int spaces= 0;
			while (start < indent) {

				char ch= fDocument.getChar(start);
				if (ch == '\t') {
					ret.append('\t');
					spaces= 0;
				} else if (convertTabs) {
					spaces++;
					if (spaces == tabLen) {
						ret.append('\t');
						spaces= 0;
					}
				} else {
					ret.append(' ');
				}

				start++;
			}
			// remainder
			while (spaces-- > 0)
				ret.append(' ');

		} catch (BadLocationException e) {
		}

		return ret;
	}

	/**
	 * Creates a string with a visual length of the given
	 * <code>indentationSize</code>.
	 *
	 * @param buffer the original indent to reuse if possible
	 * @param additional the additional indentation units to add or subtract to
	 *        reference
	 * @return the modified <code>buffer</code> reflecting the indentation
	 *         adapted to <code>additional</code>
	 */
	private StringBuffer createReusingIndent(StringBuffer buffer, int additional) {
		int refLength= computeVisualLength(buffer);
		int addLength= fPrefs.prefIndentationSize * additional; // may be < 0
		int totalLength= Math.max(0, refLength + addLength);


		// copy the reference indentation for the indent up to the last tab
		// stop within the maxCopy area
		int minLength= Math.min(totalLength, refLength);
		int tabSize= fPrefs.prefTabSize;
		int maxCopyLength= tabSize > 0 ? minLength - minLength % tabSize : minLength; // maximum indent to copy
		stripExceedingChars(buffer, maxCopyLength);


		// add additional indent
		int missing= totalLength - maxCopyLength;
		final int tabs, spaces;
		if (CCorePlugin.SPACE.equals(fPrefs.prefTabChar)) {
			tabs= 0;
			spaces= missing;
		} else if (CCorePlugin.TAB.equals(fPrefs.prefTabChar)) {
			tabs= tabSize > 0 ? missing / tabSize : 0;
			spaces= tabSize > 0 ? missing % tabSize : missing;
		} else if (CodeFormatterConstants.MIXED.equals(fPrefs.prefTabChar)) {
			tabs= tabSize > 0 ? missing / tabSize : 0;
			spaces= tabSize > 0 ? missing % tabSize : missing;
		} else {
			Assert.isTrue(false);
			return null;
		}
		for(int i= 0; i < tabs; i++)
			buffer.append('\t');
		for(int i= 0; i < spaces; i++)
			buffer.append(' ');
		return buffer;
	}

	/**
	 * Returns the reference position regarding to indentation for <code>offset</code>,
	 * or <code>NOT_FOUND</code>. This method calls
	 * {@link #findReferencePosition(int, int) findReferencePosition(offset, nextChar)} where
	 * <code>nextChar</code> is the next character after <code>offset</code>.
	 *
	 * @param offset the offset for which the reference is computed
	 * @return the reference statement relative to which <code>offset</code>
	 *         should be indented, or {@link CHeuristicScanner#NOT_FOUND}
	 */
	public int findReferencePosition(int offset) {
		return findReferencePosition(offset, peekChar(offset));
	}

	/**
	 * Peeks the next char in the document that comes after <code>offset</code>
	 * on the same line as <code>offset</code>.
	 *
	 * @param offset the offset into document
	 * @return the token symbol of the next element, or TokenEOF if there is none
	 */
	private int peekChar(int offset) {
		if (offset < fDocument.getLength()) {
			try {
				IRegion line= fDocument.getLineInformationOfOffset(offset);
				int lineOffset= line.getOffset();
				int next= fScanner.nextToken(offset, lineOffset + line.getLength());
				return next;
			} catch (BadLocationException e) {
			}
		}
		return Symbols.TokenEOF;
	}

	/**
	 * Returns the reference position regarding to indentation for <code>position</code>,
	 * or <code>NOT_FOUND</code>.
	 *
	 * <p>If <code>peekNextChar</code> is <code>true</code>, the next token after
	 * <code>offset</code> is read and taken into account when computing the
	 * indentation. Currently, if the next token is the first token on the line
	 * (i.e. only preceded by whitespace), the following tokens are specially
	 * handled:
	 * <ul>
	 * 	<li><code>switch</code> labels are indented relative to the switch block</li>
	 * 	<li>opening curly braces are aligned correctly with the introducing code</li>
	 * 	<li>closing curly braces are aligned properly with the introducing code of
	 * 		the matching opening brace</li>
	 * 	<li>closing parenthesis' are aligned with their opening peer</li>
	 * 	<li>the <code>else</code> keyword is aligned with its <code>if</code>, anything
	 * 		else is aligned normally (i.e. with the base of any introducing statements).</li>
	 *  <li>if there is no token on the same line after <code>offset</code>, the indentation
	 * 		is the same as for an <code>else</code> keyword</li>
	 * </ul>
	 *
	 * @param offset the offset for which the reference is computed
	 * @param nextToken the next token to assume in the document
	 * @return the reference statement relative to which <code>offset</code>
	 *         should be indented, or {@link CHeuristicScanner#NOT_FOUND}
	 */
	public int findReferencePosition(int offset, int nextToken) {
		boolean danglingElse= false;
		boolean unindent= false;
		boolean indent= false;
		boolean matchBrace= false;
		boolean matchParen= false;
		boolean matchCase= false;

		// account for un-indentation characters already typed in, but after position
		// if they are on a line by themselves, the indentation gets adjusted
		// accordingly
		//
		// also account for a dangling else
		if (offset < fDocument.getLength()) {
			try {
				IRegion line= fDocument.getLineInformationOfOffset(offset);
				int lineOffset= line.getOffset();
				int prevPos= Math.max(offset - 1, 0);
				boolean isFirstTokenOnLine= fDocument.get(lineOffset, prevPos + 1 - lineOffset).trim().length() == 0;
				int prevToken= fScanner.previousToken(prevPos, CHeuristicScanner.UNBOUND);
				boolean bracelessBlockStart= fScanner.isBracelessBlockStart(prevPos, CHeuristicScanner.UNBOUND);

				switch (nextToken) {
					case Symbols.TokenELSE:
						danglingElse= true;
						break;
					case Symbols.TokenCASE:
					case Symbols.TokenDEFAULT:
						if (isFirstTokenOnLine)
							matchCase= true;
						break;
					case Symbols.TokenLBRACE: // for opening-brace-on-new-line style
						if (bracelessBlockStart && !fPrefs.prefIndentBracesForBlocks)
							unindent= true;
						else if ((prevToken == Symbols.TokenCOLON || prevToken == Symbols.TokenEQUAL || prevToken == Symbols.TokenRBRACKET) && !fPrefs.prefIndentBracesForArrays)
							unindent= true;
						else if (!bracelessBlockStart && fPrefs.prefIndentBracesForMethods)
							indent= true;
						break;
					case Symbols.TokenRBRACE: // closing braces get unindented
						if (isFirstTokenOnLine)
							matchBrace= true;
						break;
					case Symbols.TokenRPAREN:
						if (isFirstTokenOnLine)
							matchParen= true;
						break;
				}
			} catch (BadLocationException e) {
			}
		} else {
			// don't assume an else could come if we are at the end of file
			danglingElse= false;
		}

		int ref= findReferencePosition(offset, danglingElse, matchBrace, matchParen, matchCase);
		if (unindent)
			fIndent--;
		if (indent)
			fIndent++;
		return ref;
	}

	/**
	 * Returns the reference position regarding to indentation for <code>position</code>,
	 * or <code>NOT_FOUND</code>.<code>fIndent</code> will contain the
	 * relative indentation (in indentation units, not characters) after the
	 * call. If there is a special alignment (e.g. for a method declaration
	 * where parameters should be aligned), <code>fAlign</code> will contain
	 * the absolute position of the alignment reference in <code>fDocument</code>,
	 * otherwise <code>fAlign</code> is set to <code>CHeuristicScanner.NOT_FOUND</code>.
	 *
	 * @param offset the offset for which the reference is computed
	 * @param danglingElse whether a dangling else should be assumed at <code>position</code>
	 * @param matchBrace whether the position of the matching brace should be
	 *            returned instead of doing code analysis
	 * @param matchParen whether the position of the matching parenthesis
	 *            should be returned instead of doing code analysis
	 * @param matchCase whether the position of a switch statement reference
	 *            should be returned (either an earlier case statement or the
	 *            switch block brace)
	 * @return the reference statement relative to which <code>position</code>
	 *         should be indented, or {@link CHeuristicScanner#NOT_FOUND}
	 */
	public int findReferencePosition(int offset, boolean danglingElse, boolean matchBrace, boolean matchParen, boolean matchCase) {
		fIndent= 0; // the indentation modification
		fAlign= CHeuristicScanner.NOT_FOUND;
		fPosition= offset;

		// forward cases
		// an unindentation happens sometimes if the next token is special, namely on braces, parens and case labels
		// align braces, but handle the case where we align with the method declaration start instead of
		// the opening brace.
		if (matchBrace) {
			if (skipScope(Symbols.TokenLBRACE, Symbols.TokenRBRACE)) {
				try {
					// align with the opening brace that is on a line by its own
					int lineOffset= fDocument.getLineOffset(fLine);
					if (lineOffset <= fPosition && fDocument.get(lineOffset, fPosition - lineOffset).trim().length() == 0)
						return fPosition;
				} catch (BadLocationException e) {
					// concurrent modification - walk default path
				}
				// if the opening brace is not on the start of the line, skip to the start
				int pos= skipToStatementStart(true, true);
				fIndent= 0; // indent is aligned with reference position
				return pos;
			} else {
				// if we can't find the matching brace, the heuristic is to unindent
				// by one against the normal position
				int pos= findReferencePosition(offset, danglingElse, false, matchParen, matchCase);
				fIndent--;
				return pos;
			}
		}

		// align parenthesis'
		if (matchParen) {
			if (skipScope(Symbols.TokenLPAREN, Symbols.TokenRPAREN))
				return fPosition;
			else {
				// if we can't find the matching paren, the heuristic is to unindent
				// by one against the normal position
				int pos= findReferencePosition(offset, danglingElse, matchBrace, false, matchCase);
				fIndent--;
				return pos;
			}
		}

		// the only reliable way to get case labels aligned (due to many different styles of using braces in a block)
		// is to go for another case statement, or the scope opening brace
		if (matchCase) {
			return matchCaseAlignment();
		}

		nextToken();
		switch (fToken) {
			case Symbols.TokenGREATERTHAN:
			case Symbols.TokenRBRACE:
				// skip the block and fall through
				// if we can't complete the scope, reset the scan position
				int pos= fPosition;
				if (!skipScope())
					fPosition= pos;
			case Symbols.TokenSEMICOLON:
				// this is the 90% case: after a statement block
				// the end of the previous statement / block previous.end
				// search to the end of the statement / block before the previous; the token just after that is previous.start
				return skipToStatementStart(danglingElse, false);

			// scope introduction: special treat who special is
			case Symbols.TokenLPAREN:
			case Symbols.TokenLBRACE:
			case Symbols.TokenLBRACKET:
				return handleScopeIntroduction(offset + 1);

			case Symbols.TokenEOF:
				// trap when hitting start of document
				return CHeuristicScanner.NOT_FOUND;

			case Symbols.TokenEQUAL:
				// indent assignments
				fIndent= fPrefs.prefAssignmentIndent;
				return fPosition;

			case Symbols.TokenCOLON:
				// TODO handle ternary deep indentation
				fIndent= fPrefs.prefCaseBlockIndent;
				return fPosition;

			case Symbols.TokenQUESTIONMARK:
				if (fPrefs.prefTernaryDeepAlign) {
					setFirstElementAlignment(fPosition, offset + 1);
					return fPosition;
				} else {
					fIndent= fPrefs.prefTernaryIndent;
					return fPosition;
				}

			// indentation for blockless introducers:
			case Symbols.TokenDO:
			case Symbols.TokenWHILE:
			case Symbols.TokenELSE:
				fIndent= fPrefs.prefSimpleIndent;
				return fPosition;

			case Symbols.TokenTRY:
				return skipToStatementStart(danglingElse, false);
			case Symbols.TokenRPAREN:
				int line= fLine;
				if (skipScope(Symbols.TokenLPAREN, Symbols.TokenRPAREN)) {
					int scope= fPosition;
					nextToken();
					if (fToken == Symbols.TokenIF || fToken == Symbols.TokenWHILE || fToken == Symbols.TokenFOR) {
						fIndent= fPrefs.prefSimpleIndent;
						return fPosition;
					}
					fPosition= scope;
					if (looksLikeMethodDecl()) {
						return skipToStatementStart(danglingElse, false);
					}
					if (fToken == Symbols.TokenCATCH) {
						return skipToStatementStart(danglingElse, false);
					}
					fPosition= scope;
					if (looksLikeAnonymousTypeDecl()) {
						return skipToStatementStart(danglingElse, false);
					}
				}
				// restore
				fPosition= offset;
				fLine= line;
				// else: fall through to default

			case Symbols.TokenCOMMA:
				// inside a list of some type
				// easy if there is already a list item before with its own indentation - we just align
				// if not: take the start of the list ( LPAREN, LBRACE, LBRACKET ) and either align or
				// indent by list-indent
			default:
				// inside whatever we don't know about: similar to the list case:
				// if we are inside a continued expression, then either align with a previous line that has indentation
				// or indent from the expression start line (either a scope introducer or the start of the expr).
				return skipToPreviousListItemOrListStart();

		}
	}

	/**
	 * Skips to the start of a statement that ends at the current position.
	 *
	 * @param danglingElse whether to indent aligned with the last <code>if</code>
	 * @param isInBlock whether the current position is inside a block, which limits the search scope to the next scope introducer
	 * @return the reference offset of the start of the statement
	 */
	private int skipToStatementStart(boolean danglingElse, boolean isInBlock) {
		final int NOTHING= 0;
		final int READ_PARENS= 1;
		final int READ_IDENT= 2;
		int mayBeMethodBody= NOTHING;
		boolean isTypeBody= false;
		while (true) {
			nextToken();

			if (isInBlock) {
				switch (fToken) {
					// exit on all block introducers
					case Symbols.TokenIF:
					case Symbols.TokenELSE:
					case Symbols.TokenCATCH:
					case Symbols.TokenDO:
					case Symbols.TokenWHILE:
					case Symbols.TokenFOR:
					case Symbols.TokenTRY:
						return fPosition;

					case Symbols.TokenSTATIC:
						mayBeMethodBody= READ_IDENT; // treat static blocks like methods
						break;

					case Symbols.TokenCLASS:
					case Symbols.TokenENUM:
						isTypeBody= true;
						break;

					case Symbols.TokenSWITCH:
						fIndent= fPrefs.prefCaseIndent;
						return fPosition;
				}
			}

			switch (fToken) {
				// scope introduction through: LPAREN, LBRACE, LBRACKET
				// search stop on SEMICOLON, RBRACE, COLON, EOF
				// -> the next token is the start of the statement (i.e. previousPos when backward scanning)
				case Symbols.TokenLPAREN:
				case Symbols.TokenLBRACE:
				case Symbols.TokenLBRACKET:
				case Symbols.TokenSEMICOLON:
				case Symbols.TokenEOF:
					if (isInBlock)
						fIndent= getBlockIndent(mayBeMethodBody == READ_IDENT, isTypeBody);
					// else: fIndent set by previous calls
					return fPreviousPos;

				case Symbols.TokenCOLON:
					int pos= fPreviousPos;
					if (!isConditional())
						return pos;
					break;

				case Symbols.TokenRBRACE:
					// RBRACE is a little tricky: it can be the end of an array definition, but
					// usually it is the end of a previous block
					pos= fPreviousPos; // store state
					if (skipScope() && looksLikeArrayInitializerIntro()) {
						continue; // it's an array
					} else {
						if (isInBlock)
							fIndent= getBlockIndent(mayBeMethodBody == READ_IDENT, isTypeBody);
						return pos; // it's not - do as with all the above
					}

				// scopes: skip them
				case Symbols.TokenRPAREN:
					if (isInBlock)
						mayBeMethodBody= READ_PARENS;
				case Symbols.TokenRBRACKET:
				case Symbols.TokenGREATERTHAN:
					pos= fPreviousPos;
					if (skipScope())
						break;
					else
						return pos;

				// IF / ELSE: align the position after the conditional block with the if
				// so we are ready for an else, except if danglingElse is false
				// in order for this to work, we must skip an else to its if
				case Symbols.TokenIF:
					if (danglingElse)
						return fPosition;
					else
						break;
				case Symbols.TokenELSE:
					// skip behind the next if, as we have that one covered
					pos= fPosition;
					if (skipNextIF())
						break;
					else
						return pos;

				case Symbols.TokenDO:
					// align the WHILE position with its do
					return fPosition;

				case Symbols.TokenWHILE:
					// this one is tricky: while can be the start of a while loop
					// or the end of a do - while
					pos= fPosition;
					if (hasMatchingDo()) {
						// continue searching from the DO on
						break;
					} else {
						// continue searching from the WHILE on
						fPosition= pos;
						break;
					}
				case Symbols.TokenIDENT:
					if (mayBeMethodBody == READ_PARENS)
						mayBeMethodBody= READ_IDENT;
					break;

				default:
					// keep searching

			}

		}
	}

	private int getBlockIndent(boolean isMethodBody, boolean isTypeBody) {
		if (isTypeBody)
			return fPrefs.prefTypeIndent + (fPrefs.prefIndentBracesForTypes ? 1 : 0);
		else if (isMethodBody)
			return fPrefs.prefMethodBodyIndent + (fPrefs.prefIndentBracesForMethods ? 1 : 0);
		else
			return fIndent;
	}

	/**
	 * Returns true if the colon at the current position is part of a conditional
	 * (ternary) expression, false otherwise.
	 *
	 * @return true if the colon at the current position is part of a conditional
	 */
	private boolean isConditional() {
		while (true) {
			nextToken();
			switch (fToken) {

				// search for case labels, which consist of (possibly qualified) identifiers or numbers
				case Symbols.TokenIDENT:
				case Symbols.TokenOTHER: // dots for qualified constants
					continue;
				case Symbols.TokenCASE:
					return false;

				default:
					return true;
			}
		}
	}

	/**
	 * Returns as a reference any previous <code>switch</code> labels (<code>case</code>
	 * or <code>default</code>) or the offset of the brace that scopes the switch
	 * statement. Sets <code>fIndent</code> to <code>prefCaseIndent</code> upon
	 * a match.
	 *
	 * @return the reference offset for a <code>switch</code> label
	 */
	private int matchCaseAlignment() {
		while (true) {
			nextToken();
			switch (fToken) {
				// invalid cases: another case label or an LBRACE must come before a case
				// -> bail out with the current position
				case Symbols.TokenLPAREN:
				case Symbols.TokenLBRACKET:
				case Symbols.TokenEOF:
					return fPosition;
				case Symbols.TokenLBRACE:
					// opening brace of switch statement
					fIndent= fPrefs.prefCaseIndent;
					return fPosition;
				case Symbols.TokenCASE:
				case Symbols.TokenDEFAULT:
					// align with previous label
					fIndent= 0;
					return fPosition;

				// scopes: skip them
				case Symbols.TokenRPAREN:
				case Symbols.TokenRBRACKET:
				case Symbols.TokenRBRACE:
				case Symbols.TokenGREATERTHAN:
					skipScope();
					break;

				default:
					// keep searching
					continue;

			}
		}
	}

	/**
	 * Returns the reference position for a list element. The algorithm
	 * tries to match any previous indentation on the same list. If there is none,
	 * the reference position returned is determined depending on the type of list:
	 * The indentation will either match the list scope introducer (e.g. for
	 * method declarations), so called deep indents, or simply increase the
	 * indentation by a number of standard indents. See also {@link #handleScopeIntroduction(int)}.
	 *
	 * @return the reference position for a list item: either a previous list item
	 * that has its own indentation, or the list introduction start.
	 */
	private int skipToPreviousListItemOrListStart() {
		int startLine= fLine;
		int startPosition= fPosition;
		while (true) {
			nextToken();

			// if any line item comes with its own indentation, adapt to it
			if (fLine < startLine) {
				try {
					int lineOffset= fDocument.getLineOffset(startLine);
					int bound= Math.min(fDocument.getLength(), startPosition + 1);
					fAlign= fScanner.findNonWhitespaceForwardInAnyPartition(lineOffset, bound);
				} catch (BadLocationException e) {
					// ignore and return just the position
				}
				return startPosition;
			}

			switch (fToken) {
				// scopes: skip them
				case Symbols.TokenRPAREN:
				case Symbols.TokenRBRACKET:
				case Symbols.TokenRBRACE:
				case Symbols.TokenGREATERTHAN:
					skipScope();
					break;

				// scope introduction: special treat who special is
				case Symbols.TokenLPAREN:
				case Symbols.TokenLBRACE:
				case Symbols.TokenLBRACKET:
					return handleScopeIntroduction(startPosition + 1);

				case Symbols.TokenSEMICOLON:
					return fPosition;
				case Symbols.TokenQUESTIONMARK:
					if (fPrefs.prefTernaryDeepAlign) {
						setFirstElementAlignment(fPosition - 1, fPosition + 1);
						return fPosition;
					} else {
						fIndent= fPrefs.prefTernaryIndent;
						return fPosition;
					}
				case Symbols.TokenEOF:
					return 0;

			}
		}
	}

	/**
	 * Skips a scope and positions the cursor (<code>fPosition</code>) on the
	 * token that opens the scope. Returns <code>true</code> if a matching peer
	 * could be found, <code>false</code> otherwise. The current token when calling
	 * must be one out of <code>Symbols.TokenRPAREN</code>, <code>Symbols.TokenRBRACE</code>,
	 * and <code>Symbols.TokenRBRACKET</code>.
	 *
	 * @return <code>true</code> if a matching peer was found, <code>false</code> otherwise
	 */
	private boolean skipScope() {
		switch (fToken) {
			case Symbols.TokenRPAREN:
				return skipScope(Symbols.TokenLPAREN, Symbols.TokenRPAREN);
			case Symbols.TokenRBRACKET:
				return skipScope(Symbols.TokenLBRACKET, Symbols.TokenRBRACKET);
			case Symbols.TokenRBRACE:
				return skipScope(Symbols.TokenLBRACE, Symbols.TokenRBRACE);
			case Symbols.TokenGREATERTHAN:
				if (!fPrefs.prefHasGenerics)
					return false;
				int storedPosition= fPosition;
				int storedToken= fToken;
				nextToken();
				switch (fToken) {
					case Symbols.TokenIDENT:
						if (!isGenericStarter(getTokenContent()))
							break;
					case Symbols.TokenQUESTIONMARK:
					case Symbols.TokenGREATERTHAN:
						if (skipScope(Symbols.TokenLESSTHAN, Symbols.TokenGREATERTHAN))
							return true;
				}
				// <> are harder to detect - restore the position if we fail
				fPosition= storedPosition;
				fToken= storedToken;
				return false;

			default:
				Assert.isTrue(false);
				return false;
		}
	}

	/**
	 * Returns the contents of the current token.
	 *
	 * @return the contents of the current token
	 */
	private CharSequence getTokenContent() {
		return new DocumentCharacterIterator(fDocument, fPosition, fPreviousPos);
	}

	/**
	 * Returns <code>true</code> if <code>identifier</code> is probably a
	 * type variable or type name, <code>false</code> if it is rather not.
	 * This is a heuristic.
	 *
	 * @param identifier the identifier to check
	 * @return <code>true</code> if <code>identifier</code> is probably a
	 *         type variable or type name, <code>false</code> if not
	 */
	private boolean isGenericStarter(CharSequence identifier) {
		/* This heuristic allows any identifiers if they start with an upper
		 * case. This will fail when a comparison is made with constants:
		 *
		 * if (MAX > foo)
		 *
		 * will try to find the matching '<' which will never come
		 *
		 * Also, it will fail on lower case types and type variables
		 */
		int length= identifier.length();
		if (length > 0 && Character.isUpperCase(identifier.charAt(0))) {
			for (int i= 0; i < length; i++) {
				if (identifier.charAt(i) == '_')
					return false;
			}
			return true;
		}
		return false;
	}

	/**
	 * Handles the introduction of a new scope. The current token must be one out
	 * of <code>Symbols.TokenLPAREN</code>, <code>Symbols.TokenLBRACE</code>,
	 * and <code>Symbols.TokenLBRACKET</code>. Returns as the reference position
	 * either the token introducing the scope or - if available - the first
	 * token after that.
	 *
	 * <p>Depending on the type of scope introduction, the indentation will align
	 * (deep indenting) with the reference position (<code>fAlign</code> will be
	 * set to the reference position) or <code>fIndent</code> will be set to
	 * the number of indentation units.
	 * </p>
	 *
	 * @param bound the bound for the search for the first token after the scope
	 * introduction.
	 * @return the indent
	 */
	private int handleScopeIntroduction(int bound) {
		switch (fToken) {
			// scope introduction: special treat who special is
			case Symbols.TokenLPAREN:
				int pos= fPosition; // store

				// special: method declaration deep indentation
				if (looksLikeMethodDecl()) {
					if (fPrefs.prefMethodDeclDeepIndent)
						return setFirstElementAlignment(pos, bound);
					else {
						fIndent= fPrefs.prefMethodDeclIndent;
						return pos;
					}
				} else {
					fPosition= pos;
					if (looksLikeMethodCall()) {
						if (fPrefs.prefMethodCallDeepIndent)
							return setFirstElementAlignment(pos, bound);
						else {
							fIndent= fPrefs.prefMethodCallIndent;
							return pos;
						}
					} else if (fPrefs.prefParenthesisDeepIndent)
						return setFirstElementAlignment(pos, bound);
				}

				// normal: return the parenthesis as reference
				fIndent= fPrefs.prefParenthesisIndent;
				return pos;

			case Symbols.TokenLBRACE:
				pos= fPosition; // store

				// special: array initializer
				if (looksLikeArrayInitializerIntro())
					if (fPrefs.prefArrayDeepIndent)
						return setFirstElementAlignment(pos, bound);
					else
						fIndent= fPrefs.prefArrayIndent;
				else
					fIndent= fPrefs.prefBlockIndent;

				// normal: skip to the statement start before the scope introducer
				// opening braces are often on differently ending indents than e.g. a method definition
				if (looksLikeArrayInitializerIntro() && !fPrefs.prefIndentBracesForArrays
						|| !fPrefs.prefIndentBracesForBlocks) {
					fPosition= pos; // restore
					return skipToStatementStart(true, true); // set to true to match the first if
				} else {
					return pos;
				}

			case Symbols.TokenLBRACKET:
				pos= fPosition; // store

				// special: method declaration deep indentation
				if (fPrefs.prefArrayDimensionsDeepIndent) {
					return setFirstElementAlignment(pos, bound);
				}

				// normal: return the bracket as reference
				fIndent= fPrefs.prefBracketIndent;
				return pos; // restore

			default:
				Assert.isTrue(false);
				return -1; // dummy
		}
	}

	/**
	 * Sets the deep indent offset (<code>fAlign</code>) to either the offset
	 * right after <code>scopeIntroducerOffset</code> or - if available - the
	 * first C token after <code>scopeIntroducerOffset</code>, but before
	 * <code>bound</code>.
	 *
	 * @param scopeIntroducerOffset the offset of the scope introducer
	 * @param bound the bound for the search for another element
	 * @return the reference position
	 */
	private int setFirstElementAlignment(int scopeIntroducerOffset, int bound) {
		int firstPossible= scopeIntroducerOffset + 1; // align with the first position after the scope intro
		fAlign= fScanner.findNonWhitespaceForwardInAnyPartition(firstPossible, bound);
		if (fAlign == CHeuristicScanner.NOT_FOUND)
			fAlign= firstPossible;
		return fAlign;
	}


	/**
	 * Returns <code>true</code> if the next token received after calling
	 * <code>nextToken</code> is either an equal sign or an array designator ('[]').
	 *
	 * @return <code>true</code> if the next elements look like the start of an array definition
	 */
	private boolean looksLikeArrayInitializerIntro() {
		nextToken();
		if (fToken == Symbols.TokenEQUAL || skipBrackets()) {
			return true;
		}
		return false;
	}

	/**
	 * Skips over the next <code>if</code> keyword. The current token when calling
	 * this method must be an <code>else</code> keyword. Returns <code>true</code>
	 * if a matching <code>if</code> could be found, <code>false</code> otherwise.
	 * The cursor (<code>fPosition</code>) is set to the offset of the <code>if</code>
	 * token.
	 *
	 * @return <code>true</code> if a matching <code>if</code> token was found, <code>false</code> otherwise
	 */
	private boolean skipNextIF() {
		Assert.isTrue(fToken == Symbols.TokenELSE);

		while (true) {
			nextToken();
			switch (fToken) {
				// scopes: skip them
				case Symbols.TokenRPAREN:
				case Symbols.TokenRBRACKET:
				case Symbols.TokenRBRACE:
				case Symbols.TokenGREATERTHAN:
					skipScope();
					break;

				case Symbols.TokenIF:
					// found it, return
					return true;
				case Symbols.TokenELSE:
					// recursively skip else-if blocks
					skipNextIF();
					break;

				// shortcut scope starts
				case Symbols.TokenLPAREN:
				case Symbols.TokenLBRACE:
				case Symbols.TokenLBRACKET:
				case Symbols.TokenEOF:
					return false;
				}
		}
	}


	/**
	 * while(condition); is ambiguous when parsed backwardly, as it is a valid
	 * statement by its own, so we have to check whether there is a matching
	 * do. A <code>do</code> can either be separated from the while by a
	 * block, or by a single statement, which limits our search distance.
	 *
	 * @return <code>true</code> if the <code>while</code> currently in
	 *         <code>fToken</code> has a matching <code>do</code>.
	 */
	private boolean hasMatchingDo() {
		Assert.isTrue(fToken == Symbols.TokenWHILE);
		nextToken();
		switch (fToken) {
			case Symbols.TokenRBRACE:
				skipScope(); // and fall thru
			case Symbols.TokenSEMICOLON:
				skipToStatementStart(false, false);
				return fToken == Symbols.TokenDO;
		}
		return false;
	}

	/**
	 * Skips brackets if the current token is a RBRACKET. There can be nothing
	 * but whitespace in between, this is only to be used for <code>[]</code> elements.
	 *
	 * @return <code>true</code> if a <code>[]</code> could be scanned, the
	 *         current token is left at the LBRACKET.
	 */
	private boolean skipBrackets() {
		if (fToken == Symbols.TokenRBRACKET) {
			nextToken();
			if (fToken == Symbols.TokenLBRACKET) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Reads the next token in backward direction from the heuristic scanner
	 * and sets the fields <code>fToken, fPreviousPosition</code> and <code>fPosition</code>
	 * accordingly.
	 */
	private void nextToken() {
		nextToken(fPosition);
	}

	/**
	 * Reads the next token in backward direction of <code>start</code> from
	 * the heuristic scanner and sets the fields <code>fToken, fPreviousPosition</code>
	 * and <code>fPosition</code> accordingly.
	 *
	 * @param start the start offset from which to scan backwards
	 */
	private void nextToken(int start) {
		fToken= fScanner.previousToken(start - 1, CHeuristicScanner.UNBOUND);
		fPreviousPos= start;
		fPosition= fScanner.getPosition() + 1;
		try {
			fLine= fDocument.getLineOfOffset(fPosition);
		} catch (BadLocationException e) {
			fLine= -1;
		}
	}

	/**
	 * Returns <code>true</code> if the current tokens look like a method
	 * declaration header (i.e. only the return type and method name). The
	 * heuristic calls <code>nextToken</code> and expects an identifier
	 * (method name) and a type declaration (an identifier with optional
	 * brackets) which also covers the visibility modifier of constructors; it
	 * does not recognize package visible constructors.
	 *
	 * @return <code>true</code> if the current position looks like a method
	 *         declaration header.
	 */
	private boolean looksLikeMethodDecl() {
		/*
		 * TODO This heuristic does not recognize package private constructors
		 * since those do have neither type nor visibility keywords.
		 * One option would be to go over the parameter list, but that might
		 * be empty as well, or not typed in yet - hard to do without an AST...
		 */

		nextToken();
		if (fToken == Symbols.TokenIDENT) { // method name
			do nextToken();
			while (skipBrackets()); // optional brackets for array valued return types

			return fToken == Symbols.TokenIDENT; // return type name

		}
		return false;
	}

	/**
	 * Returns <code>true</code> if the current tokens look like an anonymous type declaration
	 * header (i.e. a type name (potentially qualified) and a new keyword). The heuristic calls
	 * <code>nextToken</code> and expects a possibly qualified identifier (type name) and a new
	 * keyword
	 * 
	 * @return <code>true</code> if the current position looks like a anonymous type declaration
	 *         header.
	 */
	private boolean looksLikeAnonymousTypeDecl() {
		nextToken();
		if (fToken == Symbols.TokenIDENT) { // type name
			nextToken();
			while (fToken == Symbols.TokenOTHER) { // dot of qualification
				nextToken();
				if (fToken != Symbols.TokenIDENT) // qualificating name
					return false;
				nextToken();
			}
			return fToken == Symbols.TokenNEW;
		}
		return false;
	}

	/**
	 * Returns <code>true</code> if the current tokens look like a method
	 * call header (i.e. an identifier as opposed to a keyword taking parenthesized
	 * parameters such as <code>if</code>).
	 * <p>The heuristic calls <code>nextToken</code> and expects an identifier
	 * (method name).
	 *
	 * @return <code>true</code> if the current position looks like a method call
	 *         header.
	 */
	private boolean looksLikeMethodCall() {
		// TODO add awareness for constructor calls with generic types: new ArrayList<String>()
		nextToken();
		return fToken == Symbols.TokenIDENT; // method name
	}

	/**
	 * Scans tokens for the matching opening peer. The internal cursor
	 * (<code>fPosition</code>) is set to the offset of the opening peer if found.
	 *
	 * @param openToken the opening peer token
	 * @param closeToken the closing peer token
	 * @return <code>true</code> if a matching token was found, <code>false</code>
	 *         otherwise
	 */
	private boolean skipScope(int openToken, int closeToken) {

		int depth= 1;

		while (true) {
			nextToken();

			if (fToken == closeToken) {
				depth++;
			} else if (fToken == openToken) {
				depth--;
				if (depth == 0)
					return true;
			} else if (fToken == Symbols.TokenEOF) {
					return false;
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentListener;
import org.eclipse.jface.text.IDocumentPartitioner;
import org.eclipse.jface.text.IDocumentPartitioningListener;
import org.eclipse.jface.text.IPositionUpdater;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.Position;

/**
 * Minimal implementation of IDocument to apply text edit onto a string.
 */
public class SimpleDocument implements IDocument {
	
	private StringBuffer buffer;

	public SimpleDocument(String source) {
		buffer = new StringBuffer(source);
	}
	
	public SimpleDocument(char[] source) {
		buffer = new StringBuffer(source.length);
		buffer.append(source);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getChar(int)
	 */
	public char getChar(int offset) {
		return 0;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getLength()
	 */
	public int getLength() {
		return this.buffer.length();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#get()
	 */
	public String get() {
		return this.buffer.toString();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#get(int, int)
	 */
	public String get(int offset, int length) {
		return this.buffer.substring(offset, offset + length);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#set(java.lang.String)
	 */
	public void set(String text) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#replace(int, int, java.lang.String)
	 */
	public void replace(int offset, int length, String text) {
		
		this.buffer.replace(offset, offset + length, text);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#addDocumentListener(org.eclipse.jface.text.IDocumentListener)
	 */
	public void addDocumentListener(IDocumentListener listener) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#removeDocumentListener(org.eclipse.jface.text.IDocumentListener)
	 */
	public void removeDocumentListener(IDocumentListener listener) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#addPrenotifiedDocumentListener(org.eclipse.jface.text.IDocumentListener)
	 */
	public void addPrenotifiedDocumentListener(IDocumentListener documentAdapter) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#removePrenotifiedDocumentListener(org.eclipse.jface.text.IDocumentListener)
	 */
	public void removePrenotifiedDocumentListener(IDocumentListener documentAdapter) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#addPositionCategory(java.lang.String)
	 */
	public void addPositionCategory(String category) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#removePositionCategory(java.lang.String)
	 */
	public void removePositionCategory(String category) {
			// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getPositionCategories()
	 */
	public String[] getPositionCategories() {
		// defining interface method
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#containsPositionCategory(java.lang.String)
	 */
	public boolean containsPositionCategory(String category) {
		// defining interface method
		return false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#addPosition(org.eclipse.jface.text.Position)
	 */
	public void addPosition(Position position) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#removePosition(org.eclipse.jface.text.Position)
	 */
	public void removePosition(Position position) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#addPosition(java.lang.String, org.eclipse.jface.text.Position)
	 */
	public void addPosition(String category, Position position) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#removePosition(java.lang.String, org.eclipse.jface.text.Position)
	 */
	public void removePosition(String category, Position position) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getPositions(java.lang.String)
	 */
	public Position[] getPositions(String category) {
		// defining interface method
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#containsPosition(java.lang.String, int, int)
	 */
	public boolean containsPosition(String category, int offset, int length) {
		// defining interface method
		return false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#computeIndexInCategory(java.lang.String, int)
	 */
	public int computeIndexInCategory(String category, int offset) {
		// defining interface method
		return 0;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#addPositionUpdater(org.eclipse.jface.text.IPositionUpdater)
	 */
	public void addPositionUpdater(IPositionUpdater updater) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#removePositionUpdater(org.eclipse.jface.text.IPositionUpdater)
	 */
	public void removePositionUpdater(IPositionUpdater updater) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#insertPositionUpdater(org.eclipse.jface.text.IPositionUpdater, int)
	 */
	public void insertPositionUpdater(IPositionUpdater updater, int index) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getPositionUpdaters()
	 */
	public IPositionUpdater[] getPositionUpdaters() {
		// defining interface method
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getLegalContentTypes()
	 */
	public String[] getLegalContentTypes() {
		// defining interface method
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getContentType(int)
	 */
	public String getContentType(int offset) {
		// defining interface method
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getPartition(int)
	 */
	public ITypedRegion getPartition(int offset) {
		// defining interface method
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#computePartitioning(int, int)
	 */
	public ITypedRegion[] computePartitioning(int offset, int length) {
		// defining interface method
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#addDocumentPartitioningListener(org.eclipse.jface.text.IDocumentPartitioningListener)
	 */
	public void addDocumentPartitioningListener(IDocumentPartitioningListener listener) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#removeDocumentPartitioningListener(org.eclipse.jface.text.IDocumentPartitioningListener)
	 */
	public void removeDocumentPartitioningListener(IDocumentPartitioningListener listener) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#setDocumentPartitioner(org.eclipse.jface.text.IDocumentPartitioner)
	 */
	public void setDocumentPartitioner(IDocumentPartitioner partitioner) {
		// defining interface method
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getDocumentPartitioner()
	 */
	public IDocumentPartitioner getDocumentPartitioner() {
		// defining interface method
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getLineLength(int)
	 */
	public int getLineLength(int line) {
		// defining interface method
		return 0;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getLineOfOffset(int)
	 */
	public int getLineOfOffset(int offset) {
		// defining interface method
		return 0;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getLineOffset(int)
	 */
	public int getLineOffset(int line) {
		// defining interface method
		return 0;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getLineInformation(int)
	 */
	public IRegion getLineInformation(int line) {
		// defining interface method
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getLineInformationOfOffset(int)
	 */
	public IRegion getLineInformationOfOffset(int offset) {
		// defining interface method
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getNumberOfLines()
	 */
	public int getNumberOfLines() {
		// defining interface method
		return 0;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getNumberOfLines(int, int)
	 */
	public int getNumberOfLines(int offset, int length) {
		// defining interface method
		return 0;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#computeNumberOfLines(java.lang.String)
	 */
	public int computeNumberOfLines(String text) {
		// defining interface method
		return 0;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getLegalLineDelimiters()
	 */
	public String[] getLegalLineDelimiters() {
		// defining interface method
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.text.IDocument#getLineDelimiter(int)
	 */
	public String getLineDelimiter(int line) {
		// defining interface method
		return null;
	}

	/**
	 * @see org.eclipse.jface.text.IDocument#search(int, java.lang.String, boolean, boolean, boolean)
	 * @deprecated
	 */
	public int search(
		int startOffset,
		String findString,
		boolean forwardSearch,
		boolean caseSensitive,
		boolean wholeWord) {
		// defining interface method
		return 0;
	}
}




	 */
	public final static String CONTENT_TYPE_ASMSOURCE = "org.eclipse.cdt.core.asmSource"; //$NON-NLS-1$

	/**
	 * Possible  configurable option value.
	 * @see #getDefaultOptions()
	 */
	public static final String INSERT = "insert"; //$NON-NLS-1$
	/**
	 * Possible  configurable option value.
	 * @see #getDefaultOptions()
	 */
	public static final String DO_NOT_INSERT = "do not insert"; //$NON-NLS-1$
	/**
	 * Possible  configurable option value.
	 * @see #getDefaultOptions()
	 */
	public static final String TAB = "tab"; //$NON-NLS-1$
	/**
	 * Possible  configurable option value.
	 * @see #getDefaultOptions()
	 */
	public static final String SPACE = "space"; //$NON-NLS-1$

    public CDTLogWriter cdtLog = null;


Lines 7-26 Link Here

(-)src/org/eclipse/cdt/core/formatter/CodeFormatterConstants.java (-3 / +3056 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* QNX Software Systems - Initial API and implementation	9	* QNX Software Systems - Initial API and implementation
		10	* Sergey Prigogin, Google
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.cdt.core.formatter;	12	package org.eclipse.cdt.core.formatter;
12		13
		14	import java.util.Map;
		15
13	import org.eclipse.cdt.core.CCorePlugin;	16	import org.eclipse.cdt.core.CCorePlugin;
		17	import org.eclipse.cdt.internal.formatter.DefaultCodeFormatterOptions;
		18	import org.eclipse.cdt.internal.formatter.align.Alignment;
14		19
15	/**	20	/**
16	*/	21	*/
17	public class CodeFormatterConstants {	22	public class CodeFormatterConstants {
18
19		23
20	/**	24	/**
21	* <pre>	25	* <pre>
22	* FORMATTER / Option for alignment of arguments in allocation expression	26	* FORMATTER / Option for alignment of arguments in allocation expression
23	* - option id: "org.eclipse.jdt.core.formatter.language"	27	* - option id: "org.eclipse.cdt.core.formatter.language"
24	* - possible values: values proposed in class <code>ParserLanguage</code>	28	* - possible values: values proposed in class <code>ParserLanguage</code>
25	* - default: ParserLanguage.CPP	29	* - default: ParserLanguage.CPP
26	* </pre>	30	* </pre>
Lines 30-42 Link Here
30	/**	34	/**
31	* <pre>	35	* <pre>
32	* FORMATTER / Option for alignment of arguments in allocation expression	36	* FORMATTER / Option for alignment of arguments in allocation expression
33	* - option id: "org.eclipse.jdt.core.formatter.current_file"	37	* - option id: "org.eclipse.cdt.core.formatter.current_file"
34	* - possible values: object of class <code>IFile</code> or <code>null</code>	38	* - possible values: object of class <code>IFile</code> or <code>null</code>
35	* - default: null	39	* - default: null
36	* </pre>	40	* </pre>
37	*/	41	*/
38	public static final String FORMATTER_CURRENT_FILE = CCorePlugin.PLUGIN_ID + ".formatter.current_file"; //$NON-NLS-1$	42	public static final String FORMATTER_CURRENT_FILE = CCorePlugin.PLUGIN_ID + ".formatter.current_file"; //$NON-NLS-1$
39		43
		44	/**
		45	* <pre>
		46	* FORMATTER / Value to set a brace location at the end of a line.
		47	* </pre>
		48	* @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
		49	* @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
		50	* @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
		51	* @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
		52	* @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
		53	* @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
		54	* @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
		55	*/
		56	public static final String END_OF_LINE = "end_of_line"; //$NON-NLS-1$
		57
		58	/**
		59	* <pre>
		60	* FORMATTER / Value to set an option to false.
		61	* </pre>
		62	*/
		63	public static final String FALSE = "false"; //$NON-NLS-1$
		64
		65	/**
		66	* <pre>
		67	* FORMATTER / Option to align type members of a type declaration on column
		68	* - option id: "org.eclipse.cdt.core.formatter.formatter.align_type_members_on_columns"
		69	* - possible values: { TRUE, FALSE }
		70	* - default: FALSE
		71	* </pre>
		72	* @see #TRUE
		73	* @see #FALSE
		74	*/
		75	public static final String FORMATTER_ALIGN_TYPE_MEMBERS_ON_COLUMNS = CCorePlugin.PLUGIN_ID + ".formatter.align_type_members_on_columns"; //$NON-NLS-1$
		76
		77	/**
		78	* <pre>
		79	* FORMATTER / Option for alignment of arguments in allocation expression
		80	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_allocation_expression"
		81	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
		82	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
		83	* </pre>
		84	* @see #createAlignmentValue(boolean, int, int)
		85	*/
		86	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_allocation_expression"; //$NON-NLS-1$
		87	/**
		88	* <pre>
		89	* FORMATTER / Option for alignment of arguments in enum constant
		90	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_enum_constant"
		91	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
		92	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
		93	* </pre>
		94	* @see #createAlignmentValue(boolean, int, int)
		95	*/
		96	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_enum_constant"; //$NON-NLS-1$
		97	/**
		98	* <pre>
		99	* FORMATTER / Option for alignment of arguments in explicit constructor call
		100	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call"
		101	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
		102	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
		103	* </pre>
		104	* @see #createAlignmentValue(boolean, int, int)
		105	*/
		106	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_EXPLICIT_CONSTRUCTOR_CALL = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_explicit_constructor_call"; //$NON-NLS-1$
		107	/**
108	* <pre>
109	* FORMATTER / Option for alignment of arguments in method invocation
110	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_method_invocation"
111	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
112	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
113	* </pre>
114	* @see #createAlignmentValue(boolean, int, int)
115	*/
116	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_method_invocation"; //$NON-NLS-1$
117	/**
118	* <pre>
119	* FORMATTER / Option for alignment of arguments in qualified allocation expression
120	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression"
121	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
122	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
123	* </pre>
124	* @see #createAlignmentValue(boolean, int, int)
125	*/
126	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_QUALIFIED_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_qualified_allocation_expression"; //$NON-NLS-1$
127	/**
128	* <pre>
129	* FORMATTER / Option for alignment of assignment
130	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_assignment"
131	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
132	* - default: createAlignmentValue(false, M_NO_ALIGNMENT, INDENT_DEFAULT)
133	* </pre>
134	* @see #createAlignmentValue(boolean, int, int)
135	*/
136	public static final String FORMATTER_ALIGNMENT_FOR_ASSIGNMENT = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_assignment"; //$NON-NLS-1$
137	/**
138	* <pre>
139	* FORMATTER / Option for alignment of binary expression
140	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_binary_expression"
141	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
142	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
143	* </pre>
144	* @see #createAlignmentValue(boolean, int, int)
145	*/
146	public static final String FORMATTER_ALIGNMENT_FOR_BINARY_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_binary_expression"; //$NON-NLS-1$
147	/**
148	* <pre>
149	* FORMATTER / Option for alignment of compact if
150	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_compact_if"
151	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
152	* - default: createAlignmentValue(false, WRAP_ONE_PER_LINE, INDENT_BY_ONE)
153	* </pre>
154	* @see #createAlignmentValue(boolean, int, int)
155	*/
156	public static final String FORMATTER_ALIGNMENT_FOR_COMPACT_IF = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_compact_if"; //$NON-NLS-1$
157	/**
158	* <pre>
159	* FORMATTER / Option for alignment of conditional expression
160	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_conditional_expression"
161	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
162	* - default: createAlignmentValue(false, WRAP_ONE_PER_LINE, INDENT_DEFAULT)
163	* </pre>
164	* @see #createAlignmentValue(boolean, int, int)
165	*/
166	public static final String FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_conditional_expression"; //$NON-NLS-1$
167	/**
168	* <pre>
169	* FORMATTER / Option for alignment of enum constants
170	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_enum_constants"
171	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
172	* - default: createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT)
173	* </pre>
174	* @see #createAlignmentValue(boolean, int, int)
175	*/
176	public static final String FORMATTER_ALIGNMENT_FOR_ENUM_CONSTANTS = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_enum_constants"; //$NON-NLS-1$
177	/**
178	* <pre>
179	* FORMATTER / Option for alignment of expressions in array initializer
180	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_expressions_in_array_initializer"
181	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
182	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
183	* </pre>
184	* @see #createAlignmentValue(boolean, int, int)
185	*/
186	public static final String FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_expressions_in_array_initializer"; //$NON-NLS-1$
187	/**
188	* <pre>
189	* FORMATTER / Option for alignment of multiple fields
190	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_multiple_fields"
191	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
192	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
193	* </pre>
194	* @see #createAlignmentValue(boolean, int, int)
195	*/
196	public static final String FORMATTER_ALIGNMENT_FOR_MULTIPLE_FIELDS = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_multiple_fields";//$NON-NLS-1$
197	/**
198	* <pre>
199	* FORMATTER / Option for alignment of parameters in constructor declaration
200	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_parameters_in_constructor_declaration"
201	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
202	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
203	* </pre>
204	* @see #createAlignmentValue(boolean, int, int)
205	*/
206	public static final String FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_parameters_in_constructor_declaration"; //$NON-NLS-1$
207	/**
208	* <pre>
209	* FORMATTER / Option for alignment of parameters in method declaration
210	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_parameters_in_method_declaration"
211	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
212	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
213	* </pre>
214	* @see #createAlignmentValue(boolean, int, int)
215	*/
216	public static final String FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_parameters_in_method_declaration"; //$NON-NLS-1$
217	/**
218	* <pre>
219	* FORMATTER / Option for alignment of selector in method invocation
220	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_selector_in_method_invocation"
221	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
222	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
223	* </pre>
224	* @see #createAlignmentValue(boolean, int, int)
225	*/
226	public static final String FORMATTER_ALIGNMENT_FOR_SELECTOR_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_selector_in_method_invocation"; //$NON-NLS-1$
227	/**
228	* <pre>
229	* FORMATTER / Option for alignment of superclass in type declaration
230	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_superclass_in_type_declaration"
231	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
232	* - default: createAlignmentValue(false, WRAP_NEXT_SHIFTED, INDENT_DEFAULT)
233	* </pre>
234	* @see #createAlignmentValue(boolean, int, int)
235	*/
236	public static final String FORMATTER_ALIGNMENT_FOR_SUPERCLASS_IN_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_superclass_in_type_declaration"; //$NON-NLS-1$
237	/**
238	* <pre>
239	* FORMATTER / Option for alignment of superinterfaces in enum declaration
240	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration"
241	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
242	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
243	* </pre>
244	* @see #createAlignmentValue(boolean, int, int)
245	*/
246	public static final String FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_superinterfaces_in_enum_declaration"; //$NON-NLS-1$
247	/**
248	* <pre>
249	* FORMATTER / Option for alignment of superinterfaces in type declaration
250	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_superinterfaces_in_type_declaration"
251	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
252	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
253	* </pre>
254	* @see #createAlignmentValue(boolean, int, int)
255	*/
256	public static final String FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_superinterfaces_in_type_declaration"; //$NON-NLS-1$
257	/**
258	* <pre>
259	* FORMATTER / Option for alignment of throws clause in constructor declaration
260	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration"
261	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
262	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
263	* </pre>
264	* @see #createAlignmentValue(boolean, int, int)
265	*/
266	public static final String FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_throws_clause_in_constructor_declaration"; //$NON-NLS-1$
267	/**
268	* <pre>
269	* FORMATTER / Option for alignment of throws clause in method declaration
270	* - option id: "org.eclipse.cdt.core.formatter.alignment_for_throws_clause_in_method_declaration"
271	* - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call
272	* - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
273	* </pre>
274	* @see #createAlignmentValue(boolean, int, int)
275	*/
276	public static final String FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_throws_clause_in_method_declaration"; //$NON-NLS-1$
277
278	// /**
279	// * <pre>
280	// * FORMATTER / Option to add blank lines after the imports declaration
281	// * - option id: "org.eclipse.cdt.core.formatter.blank_lines_after_imports"
282	// * - possible values: "<n>", where n is zero or a positive integer
283	// * - default: "0"
284	// * </pre>
285	// */
286	// public static final String FORMATTER_BLANK_LINES_AFTER_IMPORTS = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_after_imports"; //$NON-NLS-1$
287	// /**
288	// * <pre>
289	// * FORMATTER / Option to add blank lines after the package declaration
290	// * - option id: "org.eclipse.cdt.core.formatter.blank_lines_after_package"
291	// * - possible values: "<n>", where n is zero or a positive integer
292	// * - default: "0"
293	// * </pre>
294	// */
295	// public static final String FORMATTER_BLANK_LINES_AFTER_PACKAGE = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_after_package"; //$NON-NLS-1$
296	// /**
297	// * <pre>
298	// * FORMATTER / Option to add blank lines at the beginning of the method body
299	// * - option id: "org.eclipse.cdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body"
300	// * - possible values: "<n>", where n is zero or a positive integer
301	// * - default: "0"
302	// * </pre>
303	// */
304	// public static final String FORMATTER_BLANK_LINES_AT_BEGINNING_OF_METHOD_BODY = CCorePlugin.PLUGIN_ID + ".formatter.number_of_blank_lines_at_beginning_of_method_body"; //$NON-NLS-1$
305	// /**
306	// * <pre>
307	// * FORMATTER / Option to add blank lines before a field declaration
308	// * - option id: "org.eclipse.cdt.core.formatter.blank_lines_before_field"
309	// * - possible values: "<n>", where n is zero or a positive integer
310	// * - default: "0"
311	// * </pre>
312	// */
313	// public static final String FORMATTER_BLANK_LINES_BEFORE_FIELD = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_field"; //$NON-NLS-1$
314	// /**
315	// * <pre>
316	// * FORMATTER / Option to add blank lines before the first class body declaration
317	// * - option id: "org.eclipse.cdt.core.formatter.blank_lines_before_first_class_body_declaration"
318	// * - possible values: "<n>", where n is zero or a positive integer
319	// * - default: "0"
320	// * </pre>
321	// */
322	// public static final String FORMATTER_BLANK_LINES_BEFORE_FIRST_CLASS_BODY_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_first_class_body_declaration"; //$NON-NLS-1$
323	// /**
324	// * <pre>
325	// * FORMATTER / Option to add blank lines before the imports declaration
326	// * - option id: "org.eclipse.cdt.core.formatter.blank_lines_before_imports"
327	// * - possible values: "<n>", where n is zero or a positive integer
328	// * - default: "0"
329	// * </pre>
330	// */
331	// public static final String FORMATTER_BLANK_LINES_BEFORE_IMPORTS = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_imports"; //$NON-NLS-1$
332	// /**
333	// * <pre>
334	// * FORMATTER / Option to add blank lines before a member type declaration
335	// * - option id: "org.eclipse.cdt.core.formatter.blank_lines_before_member_type"
336	// * - possible values: "<n>", where n is zero or a positive integer
337	// * - default: "0"
338	// * </pre>
339	// */
340	// public static final String FORMATTER_BLANK_LINES_BEFORE_MEMBER_TYPE = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_member_type"; //$NON-NLS-1$
341	// /**
342	// * <pre>
343	// * FORMATTER / Option to add blank lines before a method declaration
344	// * - option id: "org.eclipse.cdt.core.formatter.blank_lines_before_method"
345	// * - possible values: "<n>", where n is zero or a positive integer
346	// * - default: "0"
347	// * </pre>
348	// */
349	// public static final String FORMATTER_BLANK_LINES_BEFORE_METHOD = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_method"; //$NON-NLS-1$
350	// /**
351	// * <pre>
352	// * FORMATTER / Option to add blank lines before a new chunk
353	// * - option id: "org.eclipse.cdt.core.formatter.blank_lines_before_new_chunk"
354	// * - possible values: "<n>", where n is zero or a positive integer
355	// * - default: "0"
356	// * </pre>
357	// */
358	// public static final String FORMATTER_BLANK_LINES_BEFORE_NEW_CHUNK = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_new_chunk"; //$NON-NLS-1$
359	// /**
360	// * <pre>
361	// * FORMATTER / Option to add blank lines before the package declaration
362	// * - option id: "org.eclipse.cdt.core.formatter.blank_lines_before_package"
363	// * - possible values: "<n>", where n is zero or a positive integer
364	// * - default: "0"
365	// * </pre>
366	// */
367	// public static final String FORMATTER_BLANK_LINES_BEFORE_PACKAGE = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_package"; //$NON-NLS-1$
368	// /**
369	// * <pre>
370	// * FORMATTER / Option to add blank lines between type declarations
371	// * - option id: "org.eclipse.cdt.core.formatter.blank_lines_between_type_declarations"
372	// * - possible values: "<n>", where n is zero or a positive integer
373	// * - default: "0"
374	// * </pre>
375	// */
376	// public static final String FORMATTER_BLANK_LINES_BETWEEN_TYPE_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_between_type_declarations"; //$NON-NLS-1$
377
378	/**
379	* <pre>
380	* FORMATTER / Option to position the braces of an annotation type declaration
381	* - option id: "org.eclipse.cdt.core.formatter.brace_position_for_annotation_type_declaration"
382	* - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
383	* - default: END_OF_LINE
384	* </pre>
385	* @see #END_OF_LINE
386	* @see #NEXT_LINE
387	* @see #NEXT_LINE_SHIFTED
388	* @see #NEXT_LINE_ON_WRAP
389	*/
390	public static final String FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_array_initializer"; //$NON-NLS-1$
391	/**
392	* <pre>
393	* FORMATTER / Option to position the braces of a block
394	* - option id: "org.eclipse.cdt.core.formatter.brace_position_for_block"
395	* - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
396	* - default: END_OF_LINE
397	* </pre>
398	* @see #END_OF_LINE
399	* @see #NEXT_LINE
400	* @see #NEXT_LINE_SHIFTED
401	* @see #NEXT_LINE_ON_WRAP
402	*/
403	public static final String FORMATTER_BRACE_POSITION_FOR_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_block"; //$NON-NLS-1$
404	/**
405	* <pre>
406	* FORMATTER / Option to position the braces of a block in a case statement when the block is the first statement following
407	* the case
408	* - option id: "org.eclipse.cdt.core.formatter.brace_position_for_block_in_case"
409	* - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
410	* - default: END_OF_LINE
411	* </pre>
412	* @see #END_OF_LINE
413	* @see #NEXT_LINE
414	* @see #NEXT_LINE_SHIFTED
415	* @see #NEXT_LINE_ON_WRAP
416	*/
417	public static final String FORMATTER_BRACE_POSITION_FOR_BLOCK_IN_CASE = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_block_in_case"; //$NON-NLS-1$
418	/**
419	* <pre>
420	* FORMATTER / Option to position the braces of a constructor declaration
421	* - option id: "org.eclipse.cdt.core.formatter.brace_position_for_constructor_declaration"
422	* - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
423	* - default: END_OF_LINE
424	* </pre>
425	* @see #END_OF_LINE
426	* @see #NEXT_LINE
427	* @see #NEXT_LINE_SHIFTED
428	* @see #NEXT_LINE_ON_WRAP
429	*/
430	public static final String FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_constructor_declaration"; //$NON-NLS-1$
431	/**
432	* <pre>
433	* FORMATTER / Option to position the braces of an enum constant
434	* - option id: "org.eclipse.cdt.core.formatter.brace_position_for_enum_constant"
435	* - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
436	* - default: END_OF_LINE
437	* </pre>
438	* @see #END_OF_LINE
439	* @see #NEXT_LINE
440	* @see #NEXT_LINE_SHIFTED
441	* @see #NEXT_LINE_ON_WRAP
442	*/
443	public static final String FORMATTER_BRACE_POSITION_FOR_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_enum_constant"; //$NON-NLS-1$
444	/**
445	* <pre>
446	* FORMATTER / Option to position the braces of an enum declaration
447	* - option id: "org.eclipse.cdt.core.formatter.brace_position_for_enum_declaration"
448	* - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
449	* - default: END_OF_LINE
450	* </pre>
451	* @see #END_OF_LINE
452	* @see #NEXT_LINE
453	* @see #NEXT_LINE_SHIFTED
454	* @see #NEXT_LINE_ON_WRAP
455	*/
456	public static final String FORMATTER_BRACE_POSITION_FOR_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_enum_declaration"; //$NON-NLS-1$
457	/**
458	* <pre>
459	* FORMATTER / Option to position the braces of a method declaration
460	* - option id: "org.eclipse.cdt.core.formatter.brace_position_for_method_declaration"
461	* - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
462	* - default: END_OF_LINE
463	* </pre>
464	* @see #END_OF_LINE
465	* @see #NEXT_LINE
466	* @see #NEXT_LINE_SHIFTED
467	* @see #NEXT_LINE_ON_WRAP
468	*/
469	public static final String FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_method_declaration"; //$NON-NLS-1$
470	/**
471	* <pre>
472	* FORMATTER / Option to position the braces of a switch statement
473	* - option id: "org.eclipse.cdt.core.formatter.brace_position_for_switch"
474	* - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
475	* - default: END_OF_LINE
476	* </pre>
477	* @see #END_OF_LINE
478	* @see #NEXT_LINE
479	* @see #NEXT_LINE_SHIFTED
480	* @see #NEXT_LINE_ON_WRAP
481	*/
482	public static final String FORMATTER_BRACE_POSITION_FOR_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_switch"; //$NON-NLS-1$
483	/**
484	* <pre>
485	* FORMATTER / Option to position the braces of a type declaration
486	* - option id: "org.eclipse.cdt.core.formatter.brace_position_for_type_declaration"
487	* - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
488	* - default: END_OF_LINE
489	* </pre>
490	* @see #END_OF_LINE
491	* @see #NEXT_LINE
492	* @see #NEXT_LINE_SHIFTED
493	* @see #NEXT_LINE_ON_WRAP
494	*/
495	public static final String FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_type_declaration"; //$NON-NLS-1$
496
497	// /**
498	// * <pre>
499	// * FORMATTER / Option to control whether blank lines are cleared inside comments
500	// * - option id: "org.eclipse.cdt.core.formatter.comment.clear_blank_lines"
501	// * - possible values: { TRUE, FALSE }
502	// * - default: FALSE
503	// * </pre>
504	// * @see #TRUE
505	// * @see #FALSE
506	// */
507	// public final static String FORMATTER_COMMENT_CLEAR_BLANK_LINES = CCorePlugin.PLUGIN_ID + ".formatter.comment.clear_blank_lines"; //$NON-NLS-1$
508
509	// /**
510	// * <pre>
511	// * FORMATTER / Option to control whether comments are formatted
512	// * - option id: "org.eclipse.cdt.core.formatter.comment.format_comments"
513	// * - possible values: { TRUE, FALSE }
514	// * - default: TRUE
515	// * </pre>
516	// * @see #TRUE
517	// * @see #FALSE
518	// */
519	// public final static String FORMATTER_COMMENT_FORMAT = CCorePlugin.PLUGIN_ID + ".formatter.comment.format_comments"; //$NON-NLS-1$
520
521	// /**
522	// * <pre>
523	// * FORMATTER / Option to control whether the header comment of a C/C++ source file is formatted
524	// * - option id: "org.eclipse.cdt.core.formatter.comment.format_header"
525	// * - possible values: { TRUE, FALSE }
526	// * - default: FALSE
527	// * </pre>
528	// * @see #TRUE
529	// * @see #FALSE
530	// */
531	// public final static String FORMATTER_COMMENT_FORMAT_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.comment.format_header"; //$NON-NLS-1$
532
533	// /**
534	// * <pre>
535	// * FORMATTER / Option to control whether HTML tags are formatted.
536	// * - option id: "org.eclipse.cdt.core.formatter.comment.format_html"
537	// * - possible values: { TRUE, FALSE }
538	// * - default: TRUE
539	// * </pre>
540	// * @see #TRUE
541	// * @see #FALSE
542	// */
543	// public final static String FORMATTER_COMMENT_FORMAT_HTML = CCorePlugin.PLUGIN_ID + ".formatter.comment.format_html"; //$NON-NLS-1$
544
545	// /**
546	// * <pre>
547	// * FORMATTER / Option to control whether code snippets are formatted in comments
548	// * - option id: "org.eclipse.cdt.core.formatter.comment.format_source_code"
549	// * - possible values: { TRUE, FALSE }
550	// * - default: TRUE
551	// * </pre>
552	// * @see #TRUE
553	// * @see #FALSE
554	// */
555	// public final static String FORMATTER_COMMENT_FORMAT_SOURCE = CCorePlugin.PLUGIN_ID + ".formatter.comment.format_source_code"; //$NON-NLS-1$
556
557	// /**
558	// * <pre>
559	// * FORMATTER / Option to specify the line length for comments.
560	// * - option id: "org.eclipse.cdt.core.formatter.comment.line_length"
561	// * - possible values: "<n>", where n is zero or a positive integer
562	// * - default: "80"
563	// * </pre>
564	// */
565	// public final static String FORMATTER_COMMENT_LINE_LENGTH = CCorePlugin.PLUGIN_ID + ".formatter.comment.line_length"; //$NON-NLS-1$
566
567	// /**
568	// * <pre>
569	// * FORMATTER / Option to compact else/if
570	// * - option id: "org.eclipse.cdt.core.formatter.compact_else_if"
571	// * - possible values: { TRUE, FALSE }
572	// * - default: TRUE
573	// * </pre>
574	// * @see #TRUE
575	// * @see #FALSE
576	// */
577	// public static final String FORMATTER_COMPACT_ELSE_IF = CCorePlugin.PLUGIN_ID + ".formatter.compact_else_if"; //$NON-NLS-1$
578
579	/**
580	* <pre>
581	* FORMATTER / Option to set the continuation indentation
582	* - option id: "org.eclipse.cdt.core.formatter.continuation_indentation"
583	* - possible values: "<n>", where n is zero or a positive integer
584	* - default: "2"
585	* </pre>
586	*/
587	public static final String FORMATTER_CONTINUATION_INDENTATION = CCorePlugin.PLUGIN_ID + ".formatter.continuation_indentation"; //$NON-NLS-1$
588	/**
589	* <pre>
590	* FORMATTER / Option to set the continuation indentation inside array initializer
591	* - option id: "org.eclipse.cdt.core.formatter.continuation_indentation_for_array_initializer"
592	* - possible values: "<n>", where n is zero or a positive integer
593	* - default: "2"
594	* </pre>
595	*/
596	public static final String FORMATTER_CONTINUATION_INDENTATION_FOR_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.continuation_indentation_for_array_initializer"; //$NON-NLS-1$
597	/**
598	* <pre>
599	* FORMATTER / Option to indent body declarations compare to its enclosing annotation declaration header
600	* - option id: "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header"
601	* - possible values: { TRUE, FALSE }
602	* - default: TRUE
603	* </pre>
604	* @see #TRUE
605	* @see #FALSE
606	*/
607	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ANNOTATION_DECLARATION_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_annotation_declaration_header"; //$NON-NLS-1$
608	/**
609	* <pre>
610	* FORMATTER / Option to indent body declarations compare to its enclosing enum constant header
611	* - option id: "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header"
612	* - possible values: { TRUE, FALSE }
613	* - default: TRUE
614	* </pre>
615	* @see #TRUE
616	* @see #FALSE
617	*/
618	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_CONSTANT_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_enum_constant_header"; //$NON-NLS-1$
619	/**
620	* <pre>
621	* FORMATTER / Option to indent body declarations compare to its enclosing enum declaration header
622	* - option id: "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header"
623	* - possible values: { TRUE, FALSE }
624	* - default: TRUE
625	* </pre>
626	* @see #TRUE
627	* @see #FALSE
628	*/
629	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_DECLARATION_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_enum_declaration_header"; //$NON-NLS-1$
630	/**
631	* <pre>
632	* FORMATTER / Option to indent body declarations compare to its enclosing type header
633	* - option id: "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_type_header"
634	* - possible values: { TRUE, FALSE }
635	* - default: TRUE
636	* </pre>
637	* @see #TRUE
638	* @see #FALSE
639	*/
640	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_TYPE_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_type_header"; //$NON-NLS-1$
641	/**
642	* <pre>
643	* FORMATTER / Option to indent breaks compare to cases
644	* - option id: "org.eclipse.cdt.core.formatter.indent_breaks_compare_to_cases"
645	* - possible values: { TRUE, FALSE }
646	* - default: TRUE
647	* </pre>
648	* @see #TRUE
649	* @see #FALSE
650	*/
651	public static final String FORMATTER_INDENT_BREAKS_COMPARE_TO_CASES = CCorePlugin.PLUGIN_ID + ".formatter.indent_breaks_compare_to_cases"; //$NON-NLS-1$
652	/**
653	* <pre>
654	* FORMATTER / Option to indent empty lines
655	* - option id: "org.eclipse.cdt.core.formatter.indent_empty_lines"
656	* - possible values: { TRUE, FALSE }
657	* - default: FALSE
658	* </pre>
659	* @see #TRUE
660	* @see #FALSE
661	*/
662	public static final String FORMATTER_INDENT_EMPTY_LINES = CCorePlugin.PLUGIN_ID + ".formatter.indent_empty_lines"; //$NON-NLS-1$
663	/**
664	* <pre>
665	* FORMATTER / Option to indent statements inside a block
666	* - option id: "org.eclipse.cdt.core.formatter.indent_statements_compare_to_block"
667	* - possible values: { TRUE, FALSE }
668	* - default: TRUE
669	* </pre>
670	* @see #TRUE
671	* @see #FALSE
672	*/
673	public static final String FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.indent_statements_compare_to_block"; //$NON-NLS-1$
674	/**
675	* <pre>
676	* FORMATTER / Option to indent statements inside the body of a method or a constructor
677	* - option id: "org.eclipse.cdt.core.formatter.indent_statements_compare_to_body"
678	* - possible values: { TRUE, FALSE }
679	* - default: TRUE
680	* </pre>
681	* @see #TRUE
682	* @see #FALSE
683	*/
684	public static final String FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY = CCorePlugin.PLUGIN_ID + ".formatter.indent_statements_compare_to_body"; //$NON-NLS-1$
685	/**
686	* <pre>
687	* FORMATTER / Option to indent switch statements compare to cases
688	* - option id: "org.eclipse.cdt.core.formatter.indent_switchstatements_compare_to_cases"
689	* - possible values: { TRUE, FALSE }
690	* - default: TRUE
691	* </pre>
692	* @see #TRUE
693	* @see #FALSE
694	*/
695	public static final String FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES = CCorePlugin.PLUGIN_ID + ".formatter.indent_switchstatements_compare_to_cases"; //$NON-NLS-1$
696	/**
697	* <pre>
698	* FORMATTER / Option to indent switch statements compare to switch
699	* - option id: "org.eclipse.cdt.core.formatter.indent_switchstatements_compare_to_switch"
700	* - possible values: { TRUE, FALSE }
701	* - default: TRUE
702	* </pre>
703	* @see #TRUE
704	* @see #FALSE
705	*/
706	public static final String FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.indent_switchstatements_compare_to_switch"; //$NON-NLS-1$
707
708	/**
709	* <pre>
710	* FORMATTER / Option to specify the equivalent number of spaces that represents one indentation
711	* - option id: "org.eclipse.cdt.core.formatter.indentation.size"
712	* - possible values: "<n>", where n is zero or a positive integer
713	* - default: "4"
714	* </pre>
715	* <p>This option is used only if the tab char is set to MIXED.
716	* </p>
717	* @see #FORMATTER_TAB_CHAR
718	*/
719	public static final String FORMATTER_INDENTATION_SIZE = CCorePlugin.PLUGIN_ID + ".formatter.indentation.size"; //$NON-NLS-1$
720
721	// /**
722	// * <pre>
723	// * FORMATTER / Option to insert a new line after an annotation
724	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_after_annotation"
725	// * - possible values: { INSERT, DO_NOT_INSERT }
726	// * - default: INSERT
727	// * </pre>
728	// * @see CCorePlugin#INSERT
729	// * @see CCorePlugin#DO_NOT_INSERT
730	// */
731	// public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_after_annotation";//$NON-NLS-1$
732	//
733	// /**
734	// * <pre>
735	// * FORMATTER / Option to insert a new line after the opening brace in an array initializer
736	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer"
737	// * - possible values: { INSERT, DO_NOT_INSERT }
738	// * - default: DO_NOT_INSERT
739	// * </pre>
740	// * @see CCorePlugin#INSERT
741	// * @see CCorePlugin#DO_NOT_INSERT
742	// */
743	// public static final String FORMATTER_INSERT_NEW_LINE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_after_opening_brace_in_array_initializer";//$NON-NLS-1$
744	//
745	// /**
746	// * <pre>
747	// * FORMATTER / Option to insert a new line at the end of the current file if missing
748	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_at_end_of_file_if_missing"
749	// * - possible values: { INSERT, DO_NOT_INSERT }
750	// * - default: DO_NOT_INSERT
751	// * </pre>
752	// * @see CCorePlugin#INSERT
753	// * @see CCorePlugin#DO_NOT_INSERT
754	// */
755	// public static final String FORMATTER_INSERT_NEW_LINE_AT_END_OF_FILE_IF_MISSING = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_at_end_of_file_if_missing";//$NON-NLS-1$
756	// /**
757	// * <pre>
758	// * FORMATTER / Option to insert a new line before the catch keyword in try statement
759	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_before_catch_in_try_statement"
760	// * - possible values: { INSERT, DO_NOT_INSERT }
761	// * - default: DO_NOT_INSERT
762	// * </pre>
763	// * @see CCorePlugin#INSERT
764	// * @see CCorePlugin#DO_NOT_INSERT
765	// */
766	// public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_catch_in_try_statement"; //$NON-NLS-1$
767	// /**
768	// * <pre>
769	// * FORMATTER / Option to insert a new line before the closing brace in an array initializer
770	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer"
771	// * - possible values: { INSERT, DO_NOT_INSERT }
772	// * - default: DO_NOT_INSERT
773	// * </pre>
774	// * @see CCorePlugin#INSERT
775	// * @see CCorePlugin#DO_NOT_INSERT
776	// */
777	// public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_closing_brace_in_array_initializer";//$NON-NLS-1$
778	// /**
779	// * <pre>
780	// * FORMATTER / Option to insert a new line before the else keyword in if statement
781	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_before_else_in_if_statement"
782	// * - possible values: { INSERT, DO_NOT_INSERT }
783	// * - default: DO_NOT_INSERT
784	// * </pre>
785	// * @see CCorePlugin#INSERT
786	// * @see CCorePlugin#DO_NOT_INSERT
787	// */
788	// public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_else_in_if_statement"; //$NON-NLS-1$
789	// /**
790	// * <pre>
791	// * FORMATTER / Option to insert a new line before the finally keyword in try statement
792	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_before_finally_in_try_statement"
793	// * - possible values: { INSERT, DO_NOT_INSERT }
794	// * - default: DO_NOT_INSERT
795	// * </pre>
796	// * @see CCorePlugin#INSERT
797	// * @see CCorePlugin#DO_NOT_INSERT
798	// */
799	// public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_FINALLY_IN_TRY_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_finally_in_try_statement"; //$NON-NLS-1$
800	// /**
801	// * <pre>
802	// * FORMATTER / Option to insert a new line before while in do statement
803	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_before_while_in_do_statement"
804	// * - possible values: { INSERT, DO_NOT_INSERT }
805	// * - default: DO_NOT_INSERT
806	// * </pre>
807	// * @see CCorePlugin#INSERT
808	// * @see CCorePlugin#DO_NOT_INSERT
809	// */
810	// public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_WHILE_IN_DO_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_while_in_do_statement"; //$NON-NLS-1$
811	// /**
812	// * <pre>
813	// * FORMATTER / Option to insert a new line in an empty annotation declaration
814	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_annotation_declaration"
815	// * - possible values: { INSERT, DO_NOT_INSERT }
816	// * - default: INSERT
817	// * </pre>
818	// * @see CCorePlugin#INSERT
819	// * @see CCorePlugin#DO_NOT_INSERT
820	// */
821	// public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ANNOTATION_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_annotation_declaration"; //$NON-NLS-1$
822	// /**
823	// * <pre>
824	// * FORMATTER / Option to insert a new line in an empty anonymous type declaration
825	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration"
826	// * - possible values: { INSERT, DO_NOT_INSERT }
827	// * - default: INSERT
828	// * </pre>
829	// * @see CCorePlugin#INSERT
830	// * @see CCorePlugin#DO_NOT_INSERT
831	// */
832	// public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ANONYMOUS_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_anonymous_type_declaration"; //$NON-NLS-1$
833	// /**
834	// * <pre>
835	// * FORMATTER / Option to insert a new line in an empty block
836	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_block"
837	// * - possible values: { INSERT, DO_NOT_INSERT }
838	// * - default: INSERT
839	// * </pre>
840	// * @see CCorePlugin#INSERT
841	// * @see CCorePlugin#DO_NOT_INSERT
842	// */
843	// public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_block"; //$NON-NLS-1$
844	// /**
845	// * <pre>
846	// * FORMATTER / Option to insert a new line in an empty enum constant
847	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_enum_constant"
848	// * - possible values: { INSERT, DO_NOT_INSERT }
849	// * - default: INSERT
850	// * </pre>
851	// * @see CCorePlugin#INSERT
852	// * @see CCorePlugin#DO_NOT_INSERT
853	// */
854	// public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_enum_constant"; //$NON-NLS-1$
855	// /**
856	// * <pre>
857	// * FORMATTER / Option to insert a new line in an empty enum declaration
858	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_enum_declaration"
859	// * - possible values: { INSERT, DO_NOT_INSERT }
860	// * - default: INSERT
861	// * </pre>
862	// * @see CCorePlugin#INSERT
863	// * @see CCorePlugin#DO_NOT_INSERT
864	// */
865	// public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_enum_declaration"; //$NON-NLS-1$
866	// /**
867	// * <pre>
868	// * FORMATTER / Option to insert a new line in an empty method body
869	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_method_body"
870	// * - possible values: { INSERT, DO_NOT_INSERT }
871	// * - default: INSERT
872	// * </pre>
873	// * @see CCorePlugin#INSERT
874	// * @see CCorePlugin#DO_NOT_INSERT
875	// */
876	// public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_METHOD_BODY = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_method_body"; //$NON-NLS-1$
877	// /**
878	// * <pre>
879	// * FORMATTER / Option to insert a new line in an empty type declaration
880	// * - option id: "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_type_declaration"
881	// * - possible values: { INSERT, DO_NOT_INSERT }
882	// * - default: INSERT
883	// * </pre>
884	// * @see CCorePlugin#INSERT
885	// * @see CCorePlugin#DO_NOT_INSERT
886	// */
887	// public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_type_declaration"; //$NON-NLS-1$
888	// /**
889	// * <pre>
890	// * FORMATTER / Option to insert a space after and in wilcard
891	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_and_in_type_parameter"
892	// * - possible values: { INSERT, DO_NOT_INSERT }
893	// * - default: INSERT
894	// * </pre>
895	// * @see CCorePlugin#INSERT
896	// * @see CCorePlugin#DO_NOT_INSERT
897	// */
898	// public static final String FORMATTER_INSERT_SPACE_AFTER_AND_IN_TYPE_PARAMETER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_and_in_type_parameter"; //$NON-NLS-1$
899	// /**
900	// * <pre>
901	// * FORMATTER / Option to insert a space after an assignment operator
902	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_assignment_operator"
903	// * - possible values: { INSERT, DO_NOT_INSERT }
904	// * - default: INSERT
905	// * </pre>
906	// * @see CCorePlugin#INSERT
907	// * @see CCorePlugin#DO_NOT_INSERT
908	// */
909	// public static final String FORMATTER_INSERT_SPACE_AFTER_ASSIGNMENT_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_assignment_operator"; //$NON-NLS-1$
910	// /**
911	// * <pre>
912	// * FORMATTER / Option to insert a space after at in annotation
913	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_at_in_annotation"
914	// * - possible values: { INSERT, DO_NOT_INSERT }
915	// * - default: INSERT
916	// * </pre>
917	// * @see CCorePlugin#INSERT
918	// * @see CCorePlugin#DO_NOT_INSERT
919	// */
920	// public static final String FORMATTER_INSERT_SPACE_AFTER_AT_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_at_in_annotation"; //$NON-NLS-1$
921	// /**
922	// * <pre>
923	// * FORMATTER / Option to insert a space after at in annotation type declaration
924	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_at_in_annotation_type_declaration"
925	// * - possible values: { INSERT, DO_NOT_INSERT }
926	// * - default: DO_NOT_INSERT
927	// * </pre>
928	// * @see CCorePlugin#INSERT
929	// * @see CCorePlugin#DO_NOT_INSERT
930	// */
931	// public static final String FORMATTER_INSERT_SPACE_AFTER_AT_IN_ANNOTATION_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_at_in_annotation_type_declaration"; //$NON-NLS-1$
932	// /**
933	// * <pre>
934	// * FORMATTER / Option to insert a space after a binary operator
935	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_binary_operator"
936	// * - possible values: { INSERT, DO_NOT_INSERT }
937	// * - default: INSERT
938	// * </pre>
939	// * @see CCorePlugin#INSERT
940	// * @see CCorePlugin#DO_NOT_INSERT
941	// */
942	// public static final String FORMATTER_INSERT_SPACE_AFTER_BINARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_binary_operator"; //$NON-NLS-1$
943	// /**
944	// * <pre>
945	// * FORMATTER / Option to insert a space after the closing angle bracket in type arguments
946	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments"
947	// * - possible values: { INSERT, DO_NOT_INSERT }
948	// * - default: INSERT
949	// * </pre>
950	// * @see CCorePlugin#INSERT
951	// * @see CCorePlugin#DO_NOT_INSERT
952	// */
953	// public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_angle_bracket_in_type_arguments"; //$NON-NLS-1$
954	// /**
955	// * <pre>
956	// * FORMATTER / Option to insert a space after the closing angle bracket in type parameters
957	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters"
958	// * - possible values: { INSERT, DO_NOT_INSERT }
959	// * - default: INSERT
960	// * </pre>
961	// * @see CCorePlugin#INSERT
962	// * @see CCorePlugin#DO_NOT_INSERT
963	// */
964	// public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_angle_bracket_in_type_parameters"; //$NON-NLS-1$
965	// /**
966	// * <pre>
967	// * FORMATTER / Option to insert a space after the closing brace of a block
968	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_closing_brace_in_block"
969	// * - possible values: { INSERT, DO_NOT_INSERT }
970	// * - default: INSERT
971	// * </pre>
972	// * @see CCorePlugin#INSERT
973	// * @see CCorePlugin#DO_NOT_INSERT
974	// */
975	// public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_BRACE_IN_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_brace_in_block"; //$NON-NLS-1$
976	// /**
977	// * <pre>
978	// * FORMATTER / Option to insert a space after the closing parenthesis of a cast expression
979	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_closing_paren_in_cast"
980	// * - possible values: { INSERT, DO_NOT_INSERT }
981	// * - default: INSERT
982	// * </pre>
983	// * @see CCorePlugin#INSERT
984	// * @see CCorePlugin#DO_NOT_INSERT
985	// */
986	// public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_paren_in_cast"; //$NON-NLS-1$
987	// /**
988	// * <pre>
989	// * FORMATTER / Option to insert a space after the colon in an assert statement
990	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_assert"
991	// * - possible values: { INSERT, DO_NOT_INSERT }
992	// * - default: INSERT
993	// * </pre>
994	// * @see CCorePlugin#INSERT
995	// * @see CCorePlugin#DO_NOT_INSERT
996	// */
997	// public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_ASSERT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_assert"; //$NON-NLS-1$
998	// /**
999	// * <pre>
1000	// * FORMATTER / Option to insert a space after colon in a case statement when a opening brace follows the colon
1001	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_case"
1002	// * - possible values: { INSERT, DO_NOT_INSERT }
1003	// * - default: INSERT
1004	// * </pre>
1005	// * @see CCorePlugin#INSERT
1006	// * @see CCorePlugin#DO_NOT_INSERT
1007	// */
1008	// public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CASE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_case"; //$NON-NLS-1$
1009	// /**
1010	// * <pre>
1011	// * FORMATTER / Option to insert a space after the colon in a conditional expression
1012	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_conditional"
1013	// * - possible values: { INSERT, DO_NOT_INSERT }
1014	// * - default: INSERT
1015	// * </pre>
1016	// * @see CCorePlugin#INSERT
1017	// * @see CCorePlugin#DO_NOT_INSERT
1018	// */
1019	// public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_conditional"; //$NON-NLS-1$
1020	// /**
1021	// * <pre>
1022	// * FORMATTER / Option to insert a space after colon in a for statement
1023	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_for"
1024	// * - possible values: { INSERT, DO_NOT_INSERT }
1025	// * - default: INSERT
1026	// * </pre>
1027	// * @see CCorePlugin#INSERT
1028	// * @see CCorePlugin#DO_NOT_INSERT
1029	// */
1030	// public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_for"; //$NON-NLS-1$
1031	// /**
1032	// * <pre>
1033	// * FORMATTER / Option to insert a space after the colon in a labeled statement
1034	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_labeled_statement"
1035	// * - possible values: { INSERT, DO_NOT_INSERT }
1036	// * - default: INSERT
1037	// * </pre>
1038	// * @see CCorePlugin#INSERT
1039	// * @see CCorePlugin#DO_NOT_INSERT
1040	// */
1041	// public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_LABELED_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_labeled_statement"; //$NON-NLS-1$
1042	// /**
1043	// * <pre>
1044	// * FORMATTER / Option to insert a space after the comma in an allocation expression
1045	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_allocation_expression"
1046	// * - possible values: { INSERT, DO_NOT_INSERT }
1047	// * - default: INSERT
1048	// * </pre>
1049	// * @see CCorePlugin#INSERT
1050	// * @see CCorePlugin#DO_NOT_INSERT
1051	// */
1052	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_allocation_expression"; //$NON-NLS-1$
1053	// /**
1054	// * <pre>
1055	// * FORMATTER / Option to insert a space after the comma in annotation
1056	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_annotation"
1057	// * - possible values: { INSERT, DO_NOT_INSERT }
1058	// * - default: INSERT
1059	// * </pre>
1060	// * @see CCorePlugin#INSERT
1061	// * @see CCorePlugin#DO_NOT_INSERT
1062	// */
1063	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_annotation"; //$NON-NLS-1$
1064	// /**
1065	// * <pre>
1066	// * FORMATTER / Option to insert a space after the comma in an array initializer
1067	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_array_initializer"
1068	// * - possible values: { INSERT, DO_NOT_INSERT }
1069	// * - default: INSERT
1070	// * </pre>
1071	// * @see CCorePlugin#INSERT
1072	// * @see CCorePlugin#DO_NOT_INSERT
1073	// */
1074	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_array_initializer"; //$NON-NLS-1$
1075	// /**
1076	// * <pre>
1077	// * FORMATTER / Option to insert a space after the comma in the parameters of a constructor declaration
1078	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters"
1079	// * - possible values: { INSERT, DO_NOT_INSERT }
1080	// * - default: INSERT
1081	// * </pre>
1082	// * @see CCorePlugin#INSERT
1083	// * @see CCorePlugin#DO_NOT_INSERT
1084	// */
1085	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_constructor_declaration_parameters"; //$NON-NLS-1$
1086	// /**
1087	// * <pre>
1088	// * FORMATTER / Option to insert a space after the comma in the exception names in a throws clause of a constructor declaration
1089	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws"
1090	// * - possible values: { INSERT, DO_NOT_INSERT }
1091	// * - default: INSERT
1092	// * </pre>
1093	// * @see CCorePlugin#INSERT
1094	// * @see CCorePlugin#DO_NOT_INSERT
1095	// */
1096	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_constructor_declaration_throws"; //$NON-NLS-1$
1097	// /**
1098	// * <pre>
1099	// * FORMATTER / Option to insert a space after the comma in the arguments of an enum constant
1100	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments"
1101	// * - possible values: { INSERT, DO_NOT_INSERT }
1102	// * - default: INSERT
1103	// * </pre>
1104	// * @see CCorePlugin#INSERT
1105	// * @see CCorePlugin#DO_NOT_INSERT
1106	// */
1107	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_CONSTANT_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_enum_constant_arguments"; //$NON-NLS-1$
1108	// /**
1109	// * <pre>
1110	// * FORMATTER / Option to insert a space after the comma in enum declarations
1111	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_enum_declarations"
1112	// * - possible values: { INSERT, DO_NOT_INSERT }
1113	// * - default: INSERT
1114	// * </pre>
1115	// * @see CCorePlugin#INSERT
1116	// * @see CCorePlugin#DO_NOT_INSERT
1117	// */
1118	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_enum_declarations"; //$NON-NLS-1$
1119	// /**
1120	// * <pre>
1121	// * FORMATTER / Option to insert a space after the comma in the arguments of an explicit constructor call
1122	// * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments"
1123	// * - possible values: { INSERT, DO_NOT_INSERT }
1124	// * - default: INSERT
1125	// * </pre>
1126	// * @see CCorePlugin#INSERT
1127	// * @see CCorePlugin#DO_NOT_INSERT
1128	// */
1129	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_explicitconstructorcall_arguments"; //$NON-NLS-1$
1130	// /**
1131	// * <pre>
1132	// * FORMATTER / Option to insert a space after the comma in the increments of a for statement
1133	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_for_increments"
1134	// * - possible values: { INSERT, DO_NOT_INSERT }
1135	// * - default: INSERT
1136	// * </pre>
1137	// * @see CCorePlugin#INSERT
1138	// * @see CCorePlugin#DO_NOT_INSERT
1139	// */
1140	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INCREMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_for_increments"; //$NON-NLS-1$
1141	// /**
1142	// * <pre>
1143	// * FORMATTER / Option to insert a space after the comma in the initializations of a for statement
1144	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_for_inits"
1145	// * - possible values: { INSERT, DO_NOT_INSERT }
1146	// * - default: INSERT
1147	// * </pre>
1148	// * @see CCorePlugin#INSERT
1149	// * @see CCorePlugin#DO_NOT_INSERT
1150	// */
1151	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INITS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_for_inits"; //$NON-NLS-1$
1152	// /**
1153	// * <pre>
1154	// * FORMATTER / Option to insert a space after the comma in the parameters of a method declaration
1155	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters"
1156	// * - possible values: { INSERT, DO_NOT_INSERT }
1157	// * - default: INSERT
1158	// * </pre>
1159	// * @see CCorePlugin#INSERT
1160	// * @see CCorePlugin#DO_NOT_INSERT
1161	// */
1162	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_declaration_parameters"; //$NON-NLS-1$
1163	// /**
1164	// * <pre>
1165	// * FORMATTER / Option to insert a space after the comma in the exception names in a throws clause of a method declaration
1166	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_method_declaration_throws"
1167	// * - possible values: { INSERT, DO_NOT_INSERT }
1168	// * - default: INSERT
1169	// * </pre>
1170	// * @see CCorePlugin#INSERT
1171	// * @see CCorePlugin#DO_NOT_INSERT
1172	// */
1173	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_declaration_throws"; //$NON-NLS-1$
1174	// /**
1175	// * <pre>
1176	// * FORMATTER / Option to insert a space after the comma in the arguments of a method invocation
1177	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments"
1178	// * - possible values: { INSERT, DO_NOT_INSERT }
1179	// * - default: INSERT
1180	// * </pre>
1181	// * @see CCorePlugin#INSERT
1182	// * @see CCorePlugin#DO_NOT_INSERT
1183	// */
1184	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_INVOCATION_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_invocation_arguments"; //$NON-NLS-1$
1185	// /**
1186	// * <pre>
1187	// * FORMATTER / Option to insert a space after the comma in multiple field declaration
1188	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations"
1189	// * - possible values: { INSERT, DO_NOT_INSERT }
1190	// * - default: INSERT
1191	// * </pre>
1192	// * @see CCorePlugin#INSERT
1193	// * @see CCorePlugin#DO_NOT_INSERT
1194	// */
1195	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_multiple_field_declarations"; //$NON-NLS-1$
1196	// /**
1197	// * <pre>
1198	// * FORMATTER / Option to insert a space after the comma in multiple local declaration
1199	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations"
1200	// * - possible values: { INSERT, DO_NOT_INSERT }
1201	// * - default: INSERT
1202	// * </pre>
1203	// * @see CCorePlugin#INSERT
1204	// * @see CCorePlugin#DO_NOT_INSERT
1205	// */
1206	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_multiple_local_declarations"; //$NON-NLS-1$
1207	// /**
1208	// * <pre>
1209	// * FORMATTER / Option to insert a space after the comma in parameterized type reference
1210	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference"
1211	// * - possible values: { INSERT, DO_NOT_INSERT }
1212	// * - default: INSERT
1213	// * </pre>
1214	// * @see CCorePlugin#INSERT
1215	// * @see CCorePlugin#DO_NOT_INSERT
1216	// */
1217	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_parameterized_type_reference"; //$NON-NLS-1$
1218	// /**
1219	// * <pre>
1220	// * FORMATTER / Option to insert a space after the comma in superinterfaces names of a type header
1221	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_superinterfaces"
1222	// * - possible values: { INSERT, DO_NOT_INSERT }
1223	// * - default: INSERT
1224	// * </pre>
1225	// * @see CCorePlugin#INSERT
1226	// * @see CCorePlugin#DO_NOT_INSERT
1227	// */
1228	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_SUPERINTERFACES = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_superinterfaces"; //$NON-NLS-1$
1229	// /**
1230	// * <pre>
1231	// * FORMATTER / Option to insert a space after the comma in type arguments
1232	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_type_arguments"
1233	// * - possible values: { INSERT, DO_NOT_INSERT }
1234	// * - default: INSERT
1235	// * </pre>
1236	// * @see CCorePlugin#INSERT
1237	// * @see CCorePlugin#DO_NOT_INSERT
1238	// */
1239	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_type_arguments"; //$NON-NLS-1$
1240	// /**
1241	// * <pre>
1242	// * FORMATTER / Option to insert a space after the comma in type parameters
1243	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_type_parameters"
1244	// * - possible values: { INSERT, DO_NOT_INSERT }
1245	// * - default: INSERT
1246	// * </pre>
1247	// * @see CCorePlugin#INSERT
1248	// * @see CCorePlugin#DO_NOT_INSERT
1249	// */
1250	// public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_type_parameters"; //$NON-NLS-1$
1251	// /**
1252	// * <pre>
1253	// * FORMATTER / Option to insert a space after ellipsis
1254	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_ellipsis"
1255	// * - possible values: { INSERT, DO_NOT_INSERT }
1256	// * - default: INSERT
1257	// * </pre>
1258	// * @see CCorePlugin#INSERT
1259	// * @see CCorePlugin#DO_NOT_INSERT
1260	// */
1261	// public static final String FORMATTER_INSERT_SPACE_AFTER_ELLIPSIS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_ellipsis"; //$NON-NLS-1$
1262	// /**
1263	// * <pre>
1264	// * FORMATTER / Option to insert a space after the opening angle bracket in parameterized type reference
1265	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference"
1266	// * - possible values: { INSERT, DO_NOT_INSERT }
1267	// * - default: DO_NOT_INSERT
1268	// * </pre>
1269	// * @see CCorePlugin#INSERT
1270	// * @see CCorePlugin#DO_NOT_INSERT
1271	// */
1272	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference";//$NON-NLS-1$
1273	// /**
1274	// * <pre>
1275	// * FORMATTER / Option to insert a space after the opening angle bracket in type arguments
1276	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments"
1277	// * - possible values: { INSERT, DO_NOT_INSERT }
1278	// * - default: DO_NOT_INSERT
1279	// * </pre>
1280	// * @see CCorePlugin#INSERT
1281	// * @see CCorePlugin#DO_NOT_INSERT
1282	// */
1283	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_type_arguments";//$NON-NLS-1$
1284	// /**
1285	// * <pre>
1286	// * FORMATTER / Option to insert a space after the opening angle bracket in type parameters
1287	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters"
1288	// * - possible values: { INSERT, DO_NOT_INSERT }
1289	// * - default: DO_NOT_INSERT
1290	// * </pre>
1291	// * @see CCorePlugin#INSERT
1292	// * @see CCorePlugin#DO_NOT_INSERT
1293	// */
1294	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_type_parameters";//$NON-NLS-1$
1295	// /**
1296	// * <pre>
1297	// * FORMATTER / Option to insert a space after the opening brace in an array initializer
1298	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_brace_in_array_initializer"
1299	// * - possible values: { INSERT, DO_NOT_INSERT }
1300	// * - default: DO_NOT_INSERT
1301	// * </pre>
1302	// * @see CCorePlugin#INSERT
1303	// * @see CCorePlugin#DO_NOT_INSERT
1304	// */
1305	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_brace_in_array_initializer"; //$NON-NLS-1$
1306	// /**
1307	// * <pre>
1308	// * FORMATTER / Option to insert a space after the opening bracket inside an array allocation expression
1309	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression"
1310	// * - possible values: { INSERT, DO_NOT_INSERT }
1311	// * - default: DO_NOT_INSERT
1312	// * </pre>
1313	// * @see CCorePlugin#INSERT
1314	// * @see CCorePlugin#DO_NOT_INSERT
1315	// */
1316	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_bracket_in_array_allocation_expression";//$NON-NLS-1$
1317	// /**
1318	// * <pre>
1319	// * FORMATTER / Option to insert a space after the opening bracket inside an array reference
1320	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_bracket_in_array_reference"
1321	// * - possible values: { INSERT, DO_NOT_INSERT }
1322	// * - default: DO_NOT_INSERT
1323	// * </pre>
1324	// * @see CCorePlugin#INSERT
1325	// * @see CCorePlugin#DO_NOT_INSERT
1326	// */
1327	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_bracket_in_array_reference";//$NON-NLS-1$
1328	// /**
1329	// * <pre>
1330	// * FORMATTER / Option to insert a space after the opening parenthesis in annotation
1331	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_annotation"
1332	// * - possible values: { INSERT, DO_NOT_INSERT }
1333	// * - default: DO_NOT_INSERT
1334	// * </pre>
1335	// * @see CCorePlugin#INSERT
1336	// * @see CCorePlugin#DO_NOT_INSERT
1337	// */
1338	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_annotation"; //$NON-NLS-1$
1339	// /**
1340	// * <pre>
1341	// * FORMATTER / Option to insert a space after the opening parenthesis in a cast expression
1342	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_cast"
1343	// * - possible values: { INSERT, DO_NOT_INSERT }
1344	// * - default: DO_NOT_INSERT
1345	// * </pre>
1346	// * @see CCorePlugin#INSERT
1347	// * @see CCorePlugin#DO_NOT_INSERT
1348	// */
1349	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CAST = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_cast"; //$NON-NLS-1$
1350	// /**
1351	// * <pre>
1352	// * FORMATTER / Option to insert a space after the opening parenthesis in a catch
1353	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_catch"
1354	// * - possible values: { INSERT, DO_NOT_INSERT }
1355	// * - default: DO_NOT_INSERT
1356	// * </pre>
1357	// * @see CCorePlugin#INSERT
1358	// * @see CCorePlugin#DO_NOT_INSERT
1359	// */
1360	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CATCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_catch"; //$NON-NLS-1$
1361	// /**
1362	// * <pre>
1363	// * FORMATTER / Option to insert a space after the opening parenthesis in a constructor declaration
1364	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration"
1365	// * - possible values: { INSERT, DO_NOT_INSERT }
1366	// * - default: DO_NOT_INSERT
1367	// * </pre>
1368	// * @see CCorePlugin#INSERT
1369	// * @see CCorePlugin#DO_NOT_INSERT
1370	// */
1371	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_constructor_declaration"; //$NON-NLS-1$
1372	// /**
1373	// * <pre>
1374	// * FORMATTER / Option to insert a space after the opening parenthesis in enum constant
1375	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_enum_constant"
1376	// * - possible values: { INSERT, DO_NOT_INSERT }
1377	// * - default: DO_NOT_INSERT
1378	// * </pre>
1379	// * @see CCorePlugin#INSERT
1380	// * @see CCorePlugin#DO_NOT_INSERT
1381	// */
1382	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_enum_constant"; //$NON-NLS-1$
1383	// /**
1384	// * <pre>
1385	// * FORMATTER / Option to insert a space after the opening parenthesis in a for statement
1386	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_for"
1387	// * - possible values: { INSERT, DO_NOT_INSERT }
1388	// * - default: DO_NOT_INSERT
1389	// * </pre>
1390	// * @see CCorePlugin#INSERT
1391	// * @see CCorePlugin#DO_NOT_INSERT
1392	// */
1393	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_for"; //$NON-NLS-1$
1394	// /**
1395	// * <pre>
1396	// * FORMATTER / Option to insert a space after the opening parenthesis in an if statement
1397	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_if"
1398	// * - possible values: { INSERT, DO_NOT_INSERT }
1399	// * - default: DO_NOT_INSERT
1400	// * </pre>
1401	// * @see CCorePlugin#INSERT
1402	// * @see CCorePlugin#DO_NOT_INSERT
1403	// */
1404	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_IF = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_if"; //$NON-NLS-1$
1405	// /**
1406	// * <pre>
1407	// * FORMATTER / Option to insert a space after the opening parenthesis in a method declaration
1408	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_method_declaration"
1409	// * - possible values: { INSERT, DO_NOT_INSERT }
1410	// * - default: DO_NOT_INSERT
1411	// * </pre>
1412	// * @see CCorePlugin#INSERT
1413	// * @see CCorePlugin#DO_NOT_INSERT
1414	// */
1415	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_method_declaration"; //$NON-NLS-1$
1416	// /**
1417	// * <pre>
1418	// * FORMATTER / Option to insert a space after the opening parenthesis in a method invocation
1419	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_method_invocation"
1420	// * - possible values: { INSERT, DO_NOT_INSERT }
1421	// * - default: DO_NOT_INSERT
1422	// * </pre>
1423	// * @see CCorePlugin#INSERT
1424	// * @see CCorePlugin#DO_NOT_INSERT
1425	// */
1426	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_method_invocation"; //$NON-NLS-1$
1427	// /**
1428	// * <pre>
1429	// * FORMATTER / Option to insert a space after the opening parenthesis in a parenthesized expression
1430	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression"
1431	// * - possible values: { INSERT, DO_NOT_INSERT }
1432	// * - default: DO_NOT_INSERT
1433	// * </pre>
1434	// * @see CCorePlugin#INSERT
1435	// * @see CCorePlugin#DO_NOT_INSERT
1436	// */
1437	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_parenthesized_expression"; //$NON-NLS-1$
1438	// /**
1439	// * <pre>
1440	// * FORMATTER / Option to insert a space after the opening parenthesis in a switch statement
1441	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_switch"
1442	// * - possible values: { INSERT, DO_NOT_INSERT }
1443	// * - default: DO_NOT_INSERT
1444	// * </pre>
1445	// * @see CCorePlugin#INSERT
1446	// * @see CCorePlugin#DO_NOT_INSERT
1447	// */
1448	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_switch"; //$NON-NLS-1$
1449	// /**
1450	// * <pre>
1451	// * FORMATTER / Option to insert a space after the opening parenthesis in a synchronized statement
1452	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_synchronized"
1453	// * - possible values: { INSERT, DO_NOT_INSERT }
1454	// * - default: DO_NOT_INSERT
1455	// * </pre>
1456	// * @see CCorePlugin#INSERT
1457	// * @see CCorePlugin#DO_NOT_INSERT
1458	// */
1459	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SYNCHRONIZED = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_synchronized"; //$NON-NLS-1$
1460	// /**
1461	// * <pre>
1462	// * FORMATTER / Option to insert a space after the opening parenthesis in a while statement
1463	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_while"
1464	// * - possible values: { INSERT, DO_NOT_INSERT }
1465	// * - default: DO_NOT_INSERT
1466	// * </pre>
1467	// * @see CCorePlugin#INSERT
1468	// * @see CCorePlugin#DO_NOT_INSERT
1469	// */
1470	// public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_WHILE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_while"; //$NON-NLS-1$
1471	// /**
1472	// * <pre>
1473	// * FORMATTER / Option to insert a space after a postfix operator
1474	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_postfix_operator"
1475	// * - possible values: { INSERT, DO_NOT_INSERT }
1476	// * - default: DO_NOT_INSERT
1477	// * </pre>
1478	// * @see CCorePlugin#INSERT
1479	// * @see CCorePlugin#DO_NOT_INSERT
1480	// */
1481	// public static final String FORMATTER_INSERT_SPACE_AFTER_POSTFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_postfix_operator"; //$NON-NLS-1$
1482	// /**
1483	// * <pre>
1484	// * FORMATTER / Option to insert a space after a prefix operator
1485	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_prefix_operator"
1486	// * - possible values: { INSERT, DO_NOT_INSERT }
1487	// * - default: DO_NOT_INSERT
1488	// * </pre>
1489	// * @see CCorePlugin#INSERT
1490	// * @see CCorePlugin#DO_NOT_INSERT
1491	// */
1492	// public static final String FORMATTER_INSERT_SPACE_AFTER_PREFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_prefix_operator"; //$NON-NLS-1$
1493	// /**
1494	// * <pre>
1495	// * FORMATTER / Option to insert a space after question mark in a conditional expression
1496	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_question_in_conditional"
1497	// * - possible values: { INSERT, DO_NOT_INSERT }
1498	// * - default: DO_NOT_INSERT
1499	// * </pre>
1500	// * @see CCorePlugin#INSERT
1501	// * @see CCorePlugin#DO_NOT_INSERT
1502	// */
1503	// public static final String FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_question_in_conditional"; //$NON-NLS-1$
1504	// /**
1505	// * <pre>
1506	// * FORMATTER / Option to insert a space after question mark in a wildcard
1507	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_question_in_wildcard"
1508	// * - possible values: { INSERT, DO_NOT_INSERT }
1509	// * - default: DO_NOT_INSERT
1510	// * </pre>
1511	// * @see CCorePlugin#INSERT
1512	// * @see CCorePlugin#DO_NOT_INSERT
1513	// */
1514	// public static final String FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_WILDCARD = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_question_in_wildcard"; //$NON-NLS-1$
1515	// /**
1516	// * <pre>
1517	// * FORMATTER / Option to insert a space after semicolon in a for statement
1518	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_semicolon_in_for"
1519	// * - possible values: { INSERT, DO_NOT_INSERT }
1520	// * - default: INSERT
1521	// * </pre>
1522	// * @see CCorePlugin#INSERT
1523	// * @see CCorePlugin#DO_NOT_INSERT
1524	// */
1525	// public static final String FORMATTER_INSERT_SPACE_AFTER_SEMICOLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_semicolon_in_for"; //$NON-NLS-1$
1526	// /**
1527	// * <pre>
1528	// * FORMATTER / Option to insert a space after an unary operator
1529	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_after_unary_operator"
1530	// * - possible values: { INSERT, DO_NOT_INSERT }
1531	// * - default: DO_NOT_INSERT
1532	// * </pre>
1533	// * @see CCorePlugin#INSERT
1534	// * @see CCorePlugin#DO_NOT_INSERT
1535	// */
1536	// public static final String FORMATTER_INSERT_SPACE_AFTER_UNARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_unary_operator"; //$NON-NLS-1$
1537	// /**
1538	// * <pre>
1539	// * FORMATTER / Option to insert a space before and in wildcard
1540	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_and_in_type_parameter"
1541	// * - possible values: { INSERT, DO_NOT_INSERT }
1542	// * - default: INSERT
1543	// * </pre>
1544	// * @see CCorePlugin#INSERT
1545	// * @see CCorePlugin#DO_NOT_INSERT
1546	// */
1547	// public static final String FORMATTER_INSERT_SPACE_BEFORE_AND_IN_TYPE_PARAMETER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_and_in_type_parameter"; //$NON-NLS-1$
1548	// /**
1549	// * <pre>
1550	// * FORMATTER / Option to insert a space before an assignment operator
1551	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_assignment_operator"
1552	// * - possible values: { INSERT, DO_NOT_INSERT }
1553	// * - default: INSERT
1554	// * </pre>
1555	// * @see CCorePlugin#INSERT
1556	// * @see CCorePlugin#DO_NOT_INSERT
1557	// */
1558	// public static final String FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_assignment_operator"; //$NON-NLS-1$
1559	// /**
1560	// * <pre>
1561	// * FORMATTER / Option to insert a space before at in annotation type declaration
1562	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_at_in_annotation_type_declaration"
1563	// * - possible values: { INSERT, DO_NOT_INSERT }
1564	// * - default: INSERT
1565	// * </pre>
1566	// * @see CCorePlugin#INSERT
1567	// * @see CCorePlugin#DO_NOT_INSERT
1568	// */
1569	// public static final String FORMATTER_INSERT_SPACE_BEFORE_AT_IN_ANNOTATION_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_at_in_annotation_type_declaration"; //$NON-NLS-1$
1570	// /**
1571	// * <pre>
1572	// * FORMATTER / Option to insert a space before an binary operator
1573	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_binary_operator"
1574	// * - possible values: { INSERT, DO_NOT_INSERT }
1575	// * - default: DO_NOT_INSERT
1576	// * </pre>
1577	// * @see CCorePlugin#INSERT
1578	// * @see CCorePlugin#DO_NOT_INSERT
1579	// */
1580	// public static final String FORMATTER_INSERT_SPACE_BEFORE_BINARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_binary_operator"; //$NON-NLS-1$
1581	// /**
1582	// * <pre>
1583	// * FORMATTER / Option to insert a space before the closing angle bracket in parameterized type reference
1584	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference"
1585	// * - possible values: { INSERT, DO_NOT_INSERT }
1586	// * - default: DO_NOT_INSERT
1587	// * </pre>
1588	// * @see CCorePlugin#INSERT
1589	// * @see CCorePlugin#DO_NOT_INSERT
1590	// */
1591	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference"; //$NON-NLS-1$
1592	// /**
1593	// * <pre>
1594	// * FORMATTER / Option to insert a space before the closing angle bracket in type arguments
1595	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments"
1596	// * - possible values: { INSERT, DO_NOT_INSERT }
1597	// * - default: DO_NOT_INSERT
1598	// * </pre>
1599	// * @see CCorePlugin#INSERT
1600	// * @see CCorePlugin#DO_NOT_INSERT
1601	// */
1602	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_type_arguments"; //$NON-NLS-1$
1603	// /**
1604	// * <pre>
1605	// * FORMATTER / Option to insert a space before the closing angle bracket in type parameters
1606	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters"
1607	// * - possible values: { INSERT, DO_NOT_INSERT }
1608	// * - default: DO_NOT_INSERT
1609	// * </pre>
1610	// * @see CCorePlugin#INSERT
1611	// * @see CCorePlugin#DO_NOT_INSERT
1612	// */
1613	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_type_parameters"; //$NON-NLS-1$
1614	// /**
1615	// * <pre>
1616	// * FORMATTER / Option to insert a space before the closing brace in an array initializer
1617	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_brace_in_array_initializer"
1618	// * - possible values: { INSERT, DO_NOT_INSERT }
1619	// * - default: DO_NOT_INSERT
1620	// * </pre>
1621	// * @see CCorePlugin#INSERT
1622	// * @see CCorePlugin#DO_NOT_INSERT
1623	// */
1624	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_brace_in_array_initializer"; //$NON-NLS-1$
1625	// /**
1626	// * <pre>
1627	// * FORMATTER / Option to insert a space before the closing bracket in an array allocation expression
1628	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression"
1629	// * - possible values: { INSERT, DO_NOT_INSERT }
1630	// * - default: DO_NOT_INSERT
1631	// * </pre>
1632	// * @see CCorePlugin#INSERT
1633	// * @see CCorePlugin#DO_NOT_INSERT
1634	// */
1635	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_bracket_in_array_allocation_expression";//$NON-NLS-1$
1636	// /**
1637	// * <pre>
1638	// * FORMATTER / Option to insert a space before the closing bracket in an array reference
1639	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_bracket_in_array_reference"
1640	// * - possible values: { INSERT, DO_NOT_INSERT }
1641	// * - default: DO_NOT_INSERT
1642	// * </pre>
1643	// * @see CCorePlugin#INSERT
1644	// * @see CCorePlugin#DO_NOT_INSERT
1645	// */
1646	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_bracket_in_array_reference";//$NON-NLS-1$
1647	// /**
1648	// * <pre>
1649	// * FORMATTER / Option to insert a space before the closing parenthesis in annotation
1650	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_annotation"
1651	// * - possible values: { INSERT, DO_NOT_INSERT }
1652	// * - default: DO_NOT_INSERT
1653	// * </pre>
1654	// * @see CCorePlugin#INSERT
1655	// * @see CCorePlugin#DO_NOT_INSERT
1656	// */
1657	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_annotation"; //$NON-NLS-1$
1658	// /**
1659	// * <pre>
1660	// * FORMATTER / Option to insert a space before the closing parenthesis in a cast expression
1661	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_cast"
1662	// * - possible values: { INSERT, DO_NOT_INSERT }
1663	// * - default: DO_NOT_INSERT
1664	// * </pre>
1665	// * @see CCorePlugin#INSERT
1666	// * @see CCorePlugin#DO_NOT_INSERT
1667	// */
1668	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CAST = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_cast"; //$NON-NLS-1$
1669	// /**
1670	// * <pre>
1671	// * FORMATTER / Option to insert a space before the closing parenthesis in a catch
1672	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_catch"
1673	// * - possible values: { INSERT, DO_NOT_INSERT }
1674	// * - default: DO_NOT_INSERT
1675	// * </pre>
1676	// * @see CCorePlugin#INSERT
1677	// * @see CCorePlugin#DO_NOT_INSERT
1678	// */
1679	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CATCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_catch"; //$NON-NLS-1$
1680	// /**
1681	// * <pre>
1682	// * FORMATTER / Option to insert a space before the closing parenthesis in a constructor declaration
1683	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration"
1684	// * - possible values: { INSERT, DO_NOT_INSERT }
1685	// * - default: DO_NOT_INSERT
1686	// * </pre>
1687	// * @see CCorePlugin#INSERT
1688	// * @see CCorePlugin#DO_NOT_INSERT
1689	// */
1690	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_constructor_declaration"; //$NON-NLS-1$
1691	// /**
1692	// * <pre>
1693	// * FORMATTER / Option to insert a space before the closing parenthesis in enum constant
1694	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_enum_constant"
1695	// * - possible values: { INSERT, DO_NOT_INSERT }
1696	// * - default: DO_NOT_INSERT
1697	// * </pre>
1698	// * @see CCorePlugin#INSERT
1699	// * @see CCorePlugin#DO_NOT_INSERT
1700	// */
1701	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_enum_constant"; //$NON-NLS-1$
1702	// /**
1703	// * <pre>
1704	// * FORMATTER / Option to insert a space before the closing parenthesis in a for statement
1705	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_for"
1706	// * - possible values: { INSERT, DO_NOT_INSERT }
1707	// * - default: DO_NOT_INSERT
1708	// * </pre>
1709	// * @see CCorePlugin#INSERT
1710	// * @see CCorePlugin#DO_NOT_INSERT
1711	// */
1712	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_for"; //$NON-NLS-1$
1713	// /**
1714	// * <pre>
1715	// * FORMATTER / Option to insert a space before the closing parenthesis in an if statement
1716	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_if"
1717	// * - possible values: { INSERT, DO_NOT_INSERT }
1718	// * - default: DO_NOT_INSERT
1719	// * </pre>
1720	// * @see CCorePlugin#INSERT
1721	// * @see CCorePlugin#DO_NOT_INSERT
1722	// */
1723	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_IF = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_if"; //$NON-NLS-1$
1724	// /**
1725	// * <pre>
1726	// * FORMATTER / Option to insert a space before the closing parenthesis in a method declaration
1727	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_method_declaration"
1728	// * - possible values: { INSERT, DO_NOT_INSERT }
1729	// * - default: DO_NOT_INSERT
1730	// * </pre>
1731	// * @see CCorePlugin#INSERT
1732	// * @see CCorePlugin#DO_NOT_INSERT
1733	// */
1734	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_method_declaration"; //$NON-NLS-1$
1735	// /**
1736	// * <pre>
1737	// * FORMATTER / Option to insert a space before the closing parenthesis in a method invocation
1738	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_method_invocation"
1739	// * - possible values: { INSERT, DO_NOT_INSERT }
1740	// * - default: DO_NOT_INSERT
1741	// * </pre>
1742	// * @see CCorePlugin#INSERT
1743	// * @see CCorePlugin#DO_NOT_INSERT
1744	// */
1745	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_method_invocation"; //$NON-NLS-1$
1746	// /**
1747	// * <pre>
1748	// * FORMATTER / Option to insert a space before the closing parenthesis in a parenthesized expression
1749	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression"
1750	// * - possible values: { INSERT, DO_NOT_INSERT }
1751	// * - default: DO_NOT_INSERT
1752	// * </pre>
1753	// * @see CCorePlugin#INSERT
1754	// * @see CCorePlugin#DO_NOT_INSERT
1755	// */
1756	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_PARENTHESIZED_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_parenthesized_expression"; //$NON-NLS-1$
1757	// /**
1758	// * <pre>
1759	// * FORMATTER / Option to insert a space before the closing parenthesis in a switch statement
1760	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_switch"
1761	// * - possible values: { INSERT, DO_NOT_INSERT }
1762	// * - default: DO_NOT_INSERT
1763	// * </pre>
1764	// * @see CCorePlugin#INSERT
1765	// * @see CCorePlugin#DO_NOT_INSERT
1766	// */
1767	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_switch"; //$NON-NLS-1$
1768	// /**
1769	// * <pre>
1770	// * FORMATTER / Option to insert a space before the closing parenthesis in a synchronized statement
1771	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_synchronized"
1772	// * - possible values: { INSERT, DO_NOT_INSERT }
1773	// * - default: DO_NOT_INSERT
1774	// * </pre>
1775	// * @see CCorePlugin#INSERT
1776	// * @see CCorePlugin#DO_NOT_INSERT
1777	// */
1778	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SYNCHRONIZED = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_synchronized"; //$NON-NLS-1$
1779	// /**
1780	// * <pre>
1781	// * FORMATTER / Option to insert a space before the closing parenthesis in a while statement
1782	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_while"
1783	// * - possible values: { INSERT, DO_NOT_INSERT }
1784	// * - default: DO_NOT_INSERT
1785	// * </pre>
1786	// * @see CCorePlugin#INSERT
1787	// * @see CCorePlugin#DO_NOT_INSERT
1788	// */
1789	// public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_WHILE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_while"; //$NON-NLS-1$
1790	// /**
1791	// * <pre>
1792	// * FORMATTER / Option to insert a space before colon in an assert statement
1793	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_assert"
1794	// * - possible values: { INSERT, DO_NOT_INSERT }
1795	// * - default: INSERT
1796	// * </pre>
1797	// * @see CCorePlugin#INSERT
1798	// * @see CCorePlugin#DO_NOT_INSERT
1799	// */
1800	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_ASSERT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_assert"; //$NON-NLS-1$
1801	// /**
1802	// * <pre>
1803	// * FORMATTER / Option to insert a space before colon in a case statement
1804	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_case"
1805	// * - possible values: { INSERT, DO_NOT_INSERT }
1806	// * - default: INSERT
1807	// * </pre>
1808	// * @see CCorePlugin#INSERT
1809	// * @see CCorePlugin#DO_NOT_INSERT
1810	// */
1811	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CASE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_case"; //$NON-NLS-1$
1812	// /**
1813	// * <pre>
1814	// * FORMATTER / Option to insert a space before colon in a conditional expression
1815	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_conditional"
1816	// * - possible values: { INSERT, DO_NOT_INSERT }
1817	// * - default: INSERT
1818	// * </pre>
1819	// * @see CCorePlugin#INSERT
1820	// * @see CCorePlugin#DO_NOT_INSERT
1821	// */
1822	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_conditional"; //$NON-NLS-1$
1823	// /**
1824	// * <pre>
1825	// * FORMATTER / Option to insert a space before colon in a default statement
1826	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_default"
1827	// * - possible values: { INSERT, DO_NOT_INSERT }
1828	// * - default: INSERT
1829	// * </pre>
1830	// * @see CCorePlugin#INSERT
1831	// * @see CCorePlugin#DO_NOT_INSERT
1832	// */
1833	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_DEFAULT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_default"; //$NON-NLS-1$
1834	// /**
1835	// * <pre>
1836	// * FORMATTER / Option to insert a space before colon in a for statement
1837	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_for"
1838	// * - possible values: { INSERT, DO_NOT_INSERT }
1839	// * - default: INSERT
1840	// * </pre>
1841	// * @see CCorePlugin#INSERT
1842	// * @see CCorePlugin#DO_NOT_INSERT
1843	// */
1844	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_for"; //$NON-NLS-1$
1845	// /**
1846	// * <pre>
1847	// * FORMATTER / Option to insert a space before colon in a labeled statement
1848	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_labeled_statement"
1849	// * - possible values: { INSERT, DO_NOT_INSERT }
1850	// * - default: INSERT
1851	// * </pre>
1852	// * @see CCorePlugin#INSERT
1853	// * @see CCorePlugin#DO_NOT_INSERT
1854	// */
1855	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_LABELED_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_labeled_statement"; //$NON-NLS-1$
1856	// /**
1857	// * <pre>
1858	// * FORMATTER / Option to insert a space before comma in an allocation expression
1859	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_allocation_expression"
1860	// * - possible values: { INSERT, DO_NOT_INSERT }
1861	// * - default: DO_NOT_INSERT
1862	// * </pre>
1863	// * @see CCorePlugin#INSERT
1864	// * @see CCorePlugin#DO_NOT_INSERT
1865	// */
1866	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_allocation_expression"; //$NON-NLS-1$
1867	// /**
1868	// * <pre>
1869	// * FORMATTER / Option to insert a space before comma in annotation
1870	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_annotation"
1871	// * - possible values: { INSERT, DO_NOT_INSERT }
1872	// * - default: DO_NOT_INSERT
1873	// * </pre>
1874	// * @see CCorePlugin#INSERT
1875	// * @see CCorePlugin#DO_NOT_INSERT
1876	// */
1877	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_annotation"; //$NON-NLS-1$
1878	// /**
1879	// * <pre>
1880	// * FORMATTER / Option to insert a space before comma in an array initializer
1881	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_array_initializer"
1882	// * - possible values: { INSERT, DO_NOT_INSERT }
1883	// * - default: DO_NOT_INSERT
1884	// * </pre>
1885	// * @see CCorePlugin#INSERT
1886	// * @see CCorePlugin#DO_NOT_INSERT
1887	// */
1888	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_array_initializer"; //$NON-NLS-1$
1889	// /**
1890	// * <pre>
1891	// * FORMATTER / Option to insert a space before comma in the parameters of a constructor declaration
1892	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters"
1893	// * - possible values: { INSERT, DO_NOT_INSERT }
1894	// * - default: DO_NOT_INSERT
1895	// * </pre>
1896	// * @see CCorePlugin#INSERT
1897	// * @see CCorePlugin#DO_NOT_INSERT
1898	// */
1899	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_constructor_declaration_parameters"; //$NON-NLS-1$
1900	// /**
1901	// * <pre>
1902	// * FORMATTER / Option to insert a space before comma in the exception names of the throws clause of a constructor declaration
1903	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws"
1904	// * - possible values: { INSERT, DO_NOT_INSERT }
1905	// * - default: DO_NOT_INSERT
1906	// * </pre>
1907	// * @see CCorePlugin#INSERT
1908	// * @see CCorePlugin#DO_NOT_INSERT
1909	// */
1910	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_constructor_declaration_throws"; //$NON-NLS-1$
1911	// /**
1912	// * <pre>
1913	// * FORMATTER / Option to insert a space before comma in the arguments of enum constant
1914	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments"
1915	// * - possible values: { INSERT, DO_NOT_INSERT }
1916	// * - default: DO_NOT_INSERT
1917	// * </pre>
1918	// * @see CCorePlugin#INSERT
1919	// * @see CCorePlugin#DO_NOT_INSERT
1920	// */
1921	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_CONSTANT_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_enum_constant_arguments"; //$NON-NLS-1$
1922	// /**
1923	// * <pre>
1924	// * FORMATTER / Option to insert a space before comma in enum declarations
1925	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_enum_declarations"
1926	// * - possible values: { INSERT, DO_NOT_INSERT }
1927	// * - default: DO_NOT_INSERT
1928	// * </pre>
1929	// * @see CCorePlugin#INSERT
1930	// * @see CCorePlugin#DO_NOT_INSERT
1931	// */
1932	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_enum_declarations"; //$NON-NLS-1$
1933	// /**
1934	// * <pre>
1935	// * FORMATTER / Option to insert a space before comma in the arguments of an explicit constructor call
1936	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments"
1937	// * - possible values: { INSERT, DO_NOT_INSERT }
1938	// * - default: DO_NOT_INSERT
1939	// * </pre>
1940	// * @see CCorePlugin#INSERT
1941	// * @see CCorePlugin#DO_NOT_INSERT
1942	// */
1943	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_explicitconstructorcall_arguments"; //$NON-NLS-1$
1944	// /**
1945	// * <pre>
1946	// * FORMATTER / Option to insert a space before comma in the increments of a for statement
1947	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_for_increments"
1948	// * - possible values: { INSERT, DO_NOT_INSERT }
1949	// * - default: DO_NOT_INSERT
1950	// * </pre>
1951	// * @see CCorePlugin#INSERT
1952	// * @see CCorePlugin#DO_NOT_INSERT
1953	// */
1954	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INCREMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_for_increments"; //$NON-NLS-1$
1955	// /**
1956	// * <pre>
1957	// * FORMATTER / Option to insert a space before comma in the initializations of a for statement
1958	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_for_inits"
1959	// * - possible values: { INSERT, DO_NOT_INSERT }
1960	// * - default: DO_NOT_INSERT
1961	// * </pre>
1962	// * @see CCorePlugin#INSERT
1963	// * @see CCorePlugin#DO_NOT_INSERT
1964	// */
1965	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INITS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_for_inits"; //$NON-NLS-1$
1966	// /**
1967	// * <pre>
1968	// * FORMATTER / Option to insert a space before comma in the parameters of a method declaration
1969	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters"
1970	// * - possible values: { INSERT, DO_NOT_INSERT }
1971	// * - default: DO_NOT_INSERT
1972	// * </pre>
1973	// * @see CCorePlugin#INSERT
1974	// * @see CCorePlugin#DO_NOT_INSERT
1975	// */
1976	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_declaration_parameters"; //$NON-NLS-1$
1977	// /**
1978	// * <pre>
1979	// * FORMATTER / Option to insert a space before comma in the exception names of the throws clause of a method declaration
1980	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_method_declaration_throws"
1981	// * - possible values: { INSERT, DO_NOT_INSERT }
1982	// * - default: DO_NOT_INSERT
1983	// * </pre>
1984	// * @see CCorePlugin#INSERT
1985	// * @see CCorePlugin#DO_NOT_INSERT
1986	// */
1987	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_declaration_throws"; //$NON-NLS-1$
1988	// /**
1989	// * <pre>
1990	// * FORMATTER / Option to insert a space before comma in the arguments of a method invocation
1991	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments"
1992	// * - possible values: { INSERT, DO_NOT_INSERT }
1993	// * - default: DO_NOT_INSERT
1994	// * </pre>
1995	// * @see CCorePlugin#INSERT
1996	// * @see CCorePlugin#DO_NOT_INSERT
1997	// */
1998	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_INVOCATION_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_invocation_arguments"; //$NON-NLS-1$
1999	// /**
2000	// * <pre>
2001	// * FORMATTER / Option to insert a space before comma in a multiple field declaration
2002	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations"
2003	// * - possible values: { INSERT, DO_NOT_INSERT }
2004	// * - default: DO_NOT_INSERT
2005	// * </pre>
2006	// * @see CCorePlugin#INSERT
2007	// * @see CCorePlugin#DO_NOT_INSERT
2008	// */
2009	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_multiple_field_declarations"; //$NON-NLS-1$
2010	// /**
2011	// * <pre>
2012	// * FORMATTER / Option to insert a space before comma in a multiple local declaration
2013	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations"
2014	// * - possible values: { INSERT, DO_NOT_INSERT }
2015	// * - default: DO_NOT_INSERT
2016	// * </pre>
2017	// * @see CCorePlugin#INSERT
2018	// * @see CCorePlugin#DO_NOT_INSERT
2019	// */
2020	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_multiple_local_declarations"; //$NON-NLS-1$
2021	// /**
2022	// * <pre>
2023	// * FORMATTER / Option to insert a space before comma in parameterized type reference
2024	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference"
2025	// * - possible values: { INSERT, DO_NOT_INSERT }
2026	// * - default: DO_NOT_INSERT
2027	// * </pre>
2028	// * @see CCorePlugin#INSERT
2029	// * @see CCorePlugin#DO_NOT_INSERT
2030	// */
2031	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_parameterized_type_reference"; //$NON-NLS-1$
2032	// /**
2033	// * <pre>
2034	// * FORMATTER / Option to insert a space before comma in the superinterfaces names in a type header
2035	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_superinterfaces"
2036	// * - possible values: { INSERT, DO_NOT_INSERT }
2037	// * - default: DO_NOT_INSERT
2038	// * </pre>
2039	// * @see CCorePlugin#INSERT
2040	// * @see CCorePlugin#DO_NOT_INSERT
2041	// */
2042	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_SUPERINTERFACES = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_superinterfaces"; //$NON-NLS-1$
2043	// /**
2044	// * <pre>
2045	// * FORMATTER / Option to insert a space before comma in type arguments
2046	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_type_arguments"
2047	// * - possible values: { INSERT, DO_NOT_INSERT }
2048	// * - default: DO_NOT_INSERT
2049	// * </pre>
2050	// * @see CCorePlugin#INSERT
2051	// * @see CCorePlugin#DO_NOT_INSERT
2052	// */
2053	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_type_arguments"; //$NON-NLS-1$
2054	// /**
2055	// * <pre>
2056	// * FORMATTER / Option to insert a space before comma in type parameters
2057	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_type_parameters"
2058	// * - possible values: { INSERT, DO_NOT_INSERT }
2059	// * - default: DO_NOT_INSERT
2060	// * </pre>
2061	// * @see CCorePlugin#INSERT
2062	// * @see CCorePlugin#DO_NOT_INSERT
2063	// */
2064	// public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_type_parameters"; //$NON-NLS-1$
2065	// /**
2066	// * <pre>
2067	// * FORMATTER / Option to insert a space before ellipsis
2068	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_ellipsis"
2069	// * - possible values: { INSERT, DO_NOT_INSERT }
2070	// * - default: DO_NOT_INSERT
2071	// * </pre>
2072	// * @see CCorePlugin#INSERT
2073	// * @see CCorePlugin#DO_NOT_INSERT
2074	// */
2075	// public static final String FORMATTER_INSERT_SPACE_BEFORE_ELLIPSIS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_ellipsis"; //$NON-NLS-1$
2076	// /**
2077	// * <pre>
2078	// * FORMATTER / Option to insert a space before the opening angle bracket in parameterized type reference
2079	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference"
2080	// * - possible values: { INSERT, DO_NOT_INSERT }
2081	// * - default: DO_NOT_INSERT
2082	// * </pre>
2083	// * @see CCorePlugin#INSERT
2084	// * @see CCorePlugin#DO_NOT_INSERT
2085	// */
2086	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference"; //$NON-NLS-1$
2087	// /**
2088	// * <pre>
2089	// * FORMATTER / Option to insert a space before the opening angle bracket in type arguments
2090	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments"
2091	// * - possible values: { INSERT, DO_NOT_INSERT }
2092	// * - default: DO_NOT_INSERT
2093	// * </pre>
2094	// * @see CCorePlugin#INSERT
2095	// * @see CCorePlugin#DO_NOT_INSERT
2096	// */
2097	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_type_arguments"; //$NON-NLS-1$
2098	// /**
2099	// * <pre>
2100	// * FORMATTER / Option to insert a space before the opening angle bracket in type parameters
2101	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters"
2102	// * - possible values: { INSERT, DO_NOT_INSERT }
2103	// * - default: DO_NOT_INSERT
2104	// * </pre>
2105	// * @see CCorePlugin#INSERT
2106	// * @see CCorePlugin#DO_NOT_INSERT
2107	// */
2108	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_type_parameters"; //$NON-NLS-1$
2109	// /**
2110	// * <pre>
2111	// * FORMATTER / Option to insert a space before the opening brace in an annotation type declaration
2112	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration"
2113	// * - possible values: { INSERT, DO_NOT_INSERT }
2114	// * - default: INSERT
2115	// * </pre>
2116	// * @see CCorePlugin#INSERT
2117	// * @see CCorePlugin#DO_NOT_INSERT
2118	// */
2119	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ANNOTATION_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_annotation_type_declaration"; //$NON-NLS-1$
2120	// /**
2121	// * <pre>
2122	// * FORMATTER / Option to insert a space before the opening brace in an anonymous type declaration
2123	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration"
2124	// * - possible values: { INSERT, DO_NOT_INSERT }
2125	// * - default: INSERT
2126	// * </pre>
2127	// * @see CCorePlugin#INSERT
2128	// * @see CCorePlugin#DO_NOT_INSERT
2129	// */
2130	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ANONYMOUS_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_anonymous_type_declaration"; //$NON-NLS-1$
2131	// /**
2132	// * <pre>
2133	// * FORMATTER / Option to insert a space before the opening brace in an array initializer
2134	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_array_initializer"
2135	// * - possible values: { INSERT, DO_NOT_INSERT }
2136	// * - default: DO_NOT_INSERT
2137	// * </pre>
2138	// * @see CCorePlugin#INSERT
2139	// * @see CCorePlugin#DO_NOT_INSERT
2140	// */
2141	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_array_initializer"; //$NON-NLS-1$
2142	// /**
2143	// * <pre>
2144	// * FORMATTER / Option to insert a space before the opening brace in a block
2145	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_block"
2146	// * - possible values: { INSERT, DO_NOT_INSERT }
2147	// * - default: INSERT
2148	// * </pre>
2149	// * @see CCorePlugin#INSERT
2150	// * @see CCorePlugin#DO_NOT_INSERT
2151	// */
2152	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_block"; //$NON-NLS-1$
2153	// /**
2154	// * <pre>
2155	// * FORMATTER / Option to insert a space before the opening brace in a constructor declaration
2156	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration"
2157	// * - possible values: { INSERT, DO_NOT_INSERT }
2158	// * - default: INSERT
2159	// * </pre>
2160	// * @see CCorePlugin#INSERT
2161	// * @see CCorePlugin#DO_NOT_INSERT
2162	// */
2163	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_constructor_declaration"; //$NON-NLS-1$
2164	// /**
2165	// * <pre>
2166	// * FORMATTER / Option to insert a space before the opening brace in an enum constant
2167	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_enum_constant"
2168	// * - possible values: { INSERT, DO_NOT_INSERT }
2169	// * - default: INSERT
2170	// * </pre>
2171	// * @see CCorePlugin#INSERT
2172	// * @see CCorePlugin#DO_NOT_INSERT
2173	// */
2174	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_enum_constant"; //$NON-NLS-1$
2175	// /**
2176	// * <pre>
2177	// * FORMATTER / Option to insert a space before the opening brace in an enum declaration
2178	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration"
2179	// * - possible values: { INSERT, DO_NOT_INSERT }
2180	// * - default: INSERT
2181	// * </pre>
2182	// * @see CCorePlugin#INSERT
2183	// * @see CCorePlugin#DO_NOT_INSERT
2184	// */
2185	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_enum_declaration"; //$NON-NLS-1$
2186	// /**
2187	// * <pre>
2188	// * FORMATTER / Option to insert a space before the opening brace in a method declaration
2189	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_method_declaration"
2190	// * - possible values: { INSERT, DO_NOT_INSERT }
2191	// * - default: INSERT
2192	// * </pre>
2193	// * @see CCorePlugin#INSERT
2194	// * @see CCorePlugin#DO_NOT_INSERT
2195	// */
2196	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_method_declaration"; //$NON-NLS-1$
2197	// /**
2198	// * <pre>
2199	// * FORMATTER / Option to insert a space before the opening brace in a switch statement
2200	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_switch"
2201	// * - possible values: { INSERT, DO_NOT_INSERT }
2202	// * - default: INSERT
2203	// * </pre>
2204	// * @see CCorePlugin#INSERT
2205	// * @see CCorePlugin#DO_NOT_INSERT
2206	// */
2207	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_switch"; //$NON-NLS-1$
2208	// /**
2209	// * <pre>
2210	// * FORMATTER / Option to insert a space before the opening brace in a type declaration
2211	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_type_declaration"
2212	// * - possible values: { INSERT, DO_NOT_INSERT }
2213	// * - default: INSERT
2214	// * </pre>
2215	// * @see CCorePlugin#INSERT
2216	// * @see CCorePlugin#DO_NOT_INSERT
2217	// */
2218	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_type_declaration"; //$NON-NLS-1$
2219	// /**
2220	// * <pre>
2221	// * FORMATTER / Option to insert a space before the opening bracket in an array allocation expression
2222	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression"
2223	// * - possible values: { INSERT, DO_NOT_INSERT }
2224	// * - default: DO_NOT_INSERT
2225	// * </pre>
2226	// * @see CCorePlugin#INSERT
2227	// * @see CCorePlugin#DO_NOT_INSERT
2228	// */
2229	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_allocation_expression";//$NON-NLS-1$
2230	// /**
2231	// * <pre>
2232	// * FORMATTER / Option to insert a space before the opening bracket in an array reference
2233	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_bracket_in_array_reference"
2234	// * - possible values: { INSERT, DO_NOT_INSERT }
2235	// * - default: DO_NOT_INSERT
2236	// * </pre>
2237	// * @see CCorePlugin#INSERT
2238	// * @see CCorePlugin#DO_NOT_INSERT
2239	// */
2240	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_reference";//$NON-NLS-1$
2241	// /**
2242	// * <pre>
2243	// * FORMATTER / Option to insert a space before the opening bracket in an array type reference
2244	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference"
2245	// * - possible values: { INSERT, DO_NOT_INSERT }
2246	// * - default: DO_NOT_INSERT
2247	// * </pre>
2248	// * @see CCorePlugin#INSERT
2249	// * @see CCorePlugin#DO_NOT_INSERT
2250	// */
2251	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_type_reference"; //$NON-NLS-1$
2252	// /**
2253	// * <pre>
2254	// * FORMATTER / Option to insert a space before the opening parenthesis in annotation
2255	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_annotation"
2256	// * - possible values: { INSERT, DO_NOT_INSERT }
2257	// * - default: DO_NOT_INSERT
2258	// * </pre>
2259	// * @see CCorePlugin#INSERT
2260	// * @see CCorePlugin#DO_NOT_INSERT
2261	// */
2262	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_annotation"; //$NON-NLS-1$
2263	// /**
2264	// * <pre>
2265	// * FORMATTER / Option to insert a space before the opening parenthesis in annotation type member declaration
2266	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration"
2267	// * - possible values: { INSERT, DO_NOT_INSERT }
2268	// * - default: DO_NOT_INSERT
2269	// * </pre>
2270	// * @see CCorePlugin#INSERT
2271	// * @see CCorePlugin#DO_NOT_INSERT
2272	// */
2273	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ANNOTATION_TYPE_MEMBER_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration"; //$NON-NLS-1$
2274	// /**
2275	// * <pre>
2276	// * FORMATTER / Option to insert a space before the opening parenthesis in a catch
2277	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_catch"
2278	// * - possible values: { INSERT, DO_NOT_INSERT }
2279	// * - default: INSERT
2280	// * </pre>
2281	// * @see CCorePlugin#INSERT
2282	// * @see CCorePlugin#DO_NOT_INSERT
2283	// */
2284	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CATCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_catch"; //$NON-NLS-1$
2285	// /**
2286	// * <pre>
2287	// * FORMATTER / Option to insert a space before the opening parenthesis in a constructor declaration
2288	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration"
2289	// * - possible values: { INSERT, DO_NOT_INSERT }
2290	// * - default: DO_NOT_INSERT
2291	// * </pre>
2292	// * @see CCorePlugin#INSERT
2293	// * @see CCorePlugin#DO_NOT_INSERT
2294	// */
2295	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_constructor_declaration"; //$NON-NLS-1$
2296	// /**
2297	// * <pre>
2298	// * FORMATTER / Option to insert a space before the opening parenthesis in enum constant
2299	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_enum_constant"
2300	// * - possible values: { INSERT, DO_NOT_INSERT }
2301	// * - default: DO_NOT_INSERT
2302	// * </pre>
2303	// * @see CCorePlugin#INSERT
2304	// * @see CCorePlugin#DO_NOT_INSERT
2305	// */
2306	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_enum_constant"; //$NON-NLS-1$
2307	// /**
2308	// * <pre>
2309	// * FORMATTER / Option to insert a space before the opening parenthesis in a for statement
2310	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_for"
2311	// * - possible values: { INSERT, DO_NOT_INSERT }
2312	// * - default: INSERT
2313	// * </pre>
2314	// * @see CCorePlugin#INSERT
2315	// * @see CCorePlugin#DO_NOT_INSERT
2316	// */
2317	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_for"; //$NON-NLS-1$
2318	// /**
2319	// * <pre>
2320	// * FORMATTER / Option to insert a space before the opening parenthesis in an if statement
2321	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_if"
2322	// * - possible values: { INSERT, DO_NOT_INSERT }
2323	// * - default: INSERT
2324	// * </pre>
2325	// * @see CCorePlugin#INSERT
2326	// * @see CCorePlugin#DO_NOT_INSERT
2327	// */
2328	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_IF = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_if"; //$NON-NLS-1$
2329	// /**
2330	// * <pre>
2331	// * FORMATTER / Option to insert a space before the opening parenthesis in a method declaration
2332	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_method_declaration"
2333	// * - possible values: { INSERT, DO_NOT_INSERT }
2334	// * - default: DO_NOT_INSERT
2335	// * </pre>
2336	// * @see CCorePlugin#INSERT
2337	// * @see CCorePlugin#DO_NOT_INSERT
2338	// */
2339	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_method_declaration"; //$NON-NLS-1$
2340	// /**
2341	// * <pre>
2342	// * FORMATTER / Option to insert a space before the opening parenthesis in a method invocation
2343	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_method_invocation"
2344	// * - possible values: { INSERT, DO_NOT_INSERT }
2345	// * - default: DO_NOT_INSERT
2346	// * </pre>
2347	// * @see CCorePlugin#INSERT
2348	// * @see CCorePlugin#DO_NOT_INSERT
2349	// */
2350	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_method_invocation"; //$NON-NLS-1$
2351	// /**
2352	// * <pre>
2353	// * FORMATTER / Option to insert a space before the opening parenthesis in a parenthesized expression
2354	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression"
2355	// * - possible values: { INSERT, DO_NOT_INSERT }
2356	// * - default: DO_NOT_INSERT
2357	// * </pre>
2358	// * @see CCorePlugin#INSERT
2359	// * @see CCorePlugin#DO_NOT_INSERT
2360	// */
2361	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_parenthesized_expression"; //$NON-NLS-1$
2362	// /**
2363	// * <pre>
2364	// * FORMATTER / Option to insert a space before the opening parenthesis in a switch statement
2365	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_switch"
2366	// * - possible values: { INSERT, DO_NOT_INSERT }
2367	// * - default: INSERT
2368	// * </pre>
2369	// * @see CCorePlugin#INSERT
2370	// * @see CCorePlugin#DO_NOT_INSERT
2371	// */
2372	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_switch"; //$NON-NLS-1$
2373	// /**
2374	// * <pre>
2375	// * FORMATTER / Option to insert a space before the opening parenthesis in a synchronized statement
2376	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_synchronized"
2377	// * - possible values: { INSERT, DO_NOT_INSERT }
2378	// * - default: INSERT
2379	// * </pre>
2380	// * @see CCorePlugin#INSERT
2381	// * @see CCorePlugin#DO_NOT_INSERT
2382	// */
2383	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SYNCHRONIZED = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_synchronized"; //$NON-NLS-1$
2384	// /**
2385	// * <pre>
2386	// * FORMATTER / Option to insert a space before the opening parenthesis in a while statement
2387	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_while"
2388	// * - possible values: { INSERT, DO_NOT_INSERT }
2389	// * - default: INSERT
2390	// * </pre>
2391	// * @see CCorePlugin#INSERT
2392	// * @see CCorePlugin#DO_NOT_INSERT
2393	// */
2394	// public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_WHILE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_while"; //$NON-NLS-1$
2395	// /**
2396	// * <pre>
2397	// * FORMATTER / Option to insert a space before parenthesized expression in return statement
2398	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_parenthesized_expression_in_return"
2399	// * - possible values: { INSERT, DO_NOT_INSERT }
2400	// * - default: INSERT
2401	// * </pre>
2402	// *
2403	// * @see CCorePlugin#INSERT
2404	// * @see CCorePlugin#DO_NOT_INSERT
2405	// */
2406	// public static final String FORMATTER_INSERT_SPACE_BEFORE_PARENTHESIZED_EXPRESSION_IN_RETURN = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_parenthesized_expression_in_return"; //$NON-NLS-1$
2407	// /**
2408	// * <pre>
2409	// * FORMATTER / Option to insert a space before a postfix operator
2410	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_postfix_operator"
2411	// * - possible values: { INSERT, DO_NOT_INSERT }
2412	// * - default: DO_NOT_INSERT
2413	// * </pre>
2414	// * @see CCorePlugin#INSERT
2415	// * @see CCorePlugin#DO_NOT_INSERT
2416	// */
2417	// public static final String FORMATTER_INSERT_SPACE_BEFORE_POSTFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_postfix_operator"; //$NON-NLS-1$
2418	// /**
2419	// * <pre>
2420	// * FORMATTER / Option to insert a space before a prefix operator
2421	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_prefix_operator"
2422	// * - possible values: { INSERT, DO_NOT_INSERT }
2423	// * - default: DO_NOT_INSERT
2424	// * </pre>
2425	// * @see CCorePlugin#INSERT
2426	// * @see CCorePlugin#DO_NOT_INSERT
2427	// */
2428	// public static final String FORMATTER_INSERT_SPACE_BEFORE_PREFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_prefix_operator"; //$NON-NLS-1$
2429	// /**
2430	// * <pre>
2431	// * FORMATTER / Option to insert a space before question mark in a conditional expression
2432	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_question_in_conditional"
2433	// * - possible values: { INSERT, DO_NOT_INSERT }
2434	// * - default: INSERT
2435	// * </pre>
2436	// * @see CCorePlugin#INSERT
2437	// * @see CCorePlugin#DO_NOT_INSERT
2438	// */
2439	// public static final String FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_question_in_conditional"; //$NON-NLS-1$
2440	// /**
2441	// * <pre>
2442	// * FORMATTER / Option to insert a space before question mark in a wildcard
2443	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_question_in_wildcard"
2444	// * - possible values: { INSERT, DO_NOT_INSERT }
2445	// * - default: DO_NOT_INSERT
2446	// * </pre>
2447	// * @see CCorePlugin#INSERT
2448	// * @see CCorePlugin#DO_NOT_INSERT
2449	// */
2450	// public static final String FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_WILDCARD = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_question_in_wildcard"; //$NON-NLS-1$
2451	// /**
2452	// * <pre>
2453	// * FORMATTER / Option to insert a space before semicolon
2454	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_semicolon"
2455	// * - possible values: { INSERT, DO_NOT_INSERT }
2456	// * - default: DO_NOT_INSERT
2457	// * </pre>
2458	// * @see CCorePlugin#INSERT
2459	// * @see CCorePlugin#DO_NOT_INSERT
2460	// */
2461	// public static final String FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_semicolon"; //$NON-NLS-1$
2462	// /**
2463	// * <pre>
2464	// * FORMATTER / Option to insert a space before semicolon in for statement
2465	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_semicolon_in_for"
2466	// * - possible values: { INSERT, DO_NOT_INSERT }
2467	// * - default: DO_NOT_INSERT
2468	// * </pre>
2469	// * @see CCorePlugin#INSERT
2470	// * @see CCorePlugin#DO_NOT_INSERT
2471	// */
2472	// public static final String FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_semicolon_in_for"; //$NON-NLS-1$
2473	// /**
2474	// * <pre>
2475	// * FORMATTER / Option to insert a space before unary operator
2476	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_before_unary_operator"
2477	// * - possible values: { INSERT, DO_NOT_INSERT }
2478	// * - default: DO_NOT_INSERT
2479	// * </pre>
2480	// * @see CCorePlugin#INSERT
2481	// * @see CCorePlugin#DO_NOT_INSERT
2482	// */
2483	// public static final String FORMATTER_INSERT_SPACE_BEFORE_UNARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_unary_operator"; //$NON-NLS-1$
2484	//
2485	// /**
2486	// * <pre>
2487	// * FORMATTER / Option to insert a space between brackets in an array type reference
2488	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_between_brackets_in_array_type_reference"
2489	// * - possible values: { INSERT, DO_NOT_INSERT }
2490	// * - default: DO_NOT_INSERT
2491	// * </pre>
2492	// * @see CCorePlugin#INSERT
2493	// * @see CCorePlugin#DO_NOT_INSERT
2494	// */
2495	// public static final String FORMATTER_INSERT_SPACE_BETWEEN_BRACKETS_IN_ARRAY_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_brackets_in_array_type_reference"; //$NON-NLS-1$
2496	// /**
2497	// * <pre>
2498	// * FORMATTER / Option to insert a space between empty braces in an array initializer
2499	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_between_empty_braces_in_array_initializer"
2500	// * - possible values: { INSERT, DO_NOT_INSERT }
2501	// * - default: DO_NOT_INSERT
2502	// * </pre>
2503	// * @see CCorePlugin#INSERT
2504	// * @see CCorePlugin#DO_NOT_INSERT
2505	// */
2506	// public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACES_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_braces_in_array_initializer"; //$NON-NLS-1$
2507	// /**
2508	// * <pre>
2509	// * FORMATTER / Option to insert a space between empty brackets in an array allocation expression
2510	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression"
2511	// * - possible values: { INSERT, DO_NOT_INSERT }
2512	// * - default: DO_NOT_INSERT
2513	// * </pre>
2514	// * @see CCorePlugin#INSERT
2515	// * @see CCorePlugin#DO_NOT_INSERT
2516	// */
2517	// public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACKETS_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_brackets_in_array_allocation_expression"; //$NON-NLS-1$
2518	// /**
2519	// * <pre>
2520	// * FORMATTER / Option to insert a space between empty parenthesis in an annotation type member declaration
2521	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration"
2522	// * - possible values: { INSERT, DO_NOT_INSERT }
2523	// * - default: DO_NOT_INSERT
2524	// * </pre>
2525	// * @see CCorePlugin#INSERT
2526	// * @see CCorePlugin#DO_NOT_INSERT
2527	// */
2528	// public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_ANNOTATION_TYPE_MEMBER_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration"; //$NON-NLS-1$
2529	// /**
2530	// * <pre>
2531	// * FORMATTER / Option to insert a space between empty parenthesis in a constructor declaration
2532	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration"
2533	// * - possible values: { INSERT, DO_NOT_INSERT }
2534	// * - default: DO_NOT_INSERT
2535	// * </pre>
2536	// * @see CCorePlugin#INSERT
2537	// * @see CCorePlugin#DO_NOT_INSERT
2538	// */
2539	// public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_constructor_declaration"; //$NON-NLS-1$
2540	// /**
2541	// * <pre>
2542	// * FORMATTER / Option to insert a space between empty parenthesis in enum constant
2543	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_enum_constant"
2544	// * - possible values: { INSERT, DO_NOT_INSERT }
2545	// * - default: DO_NOT_INSERT
2546	// * </pre>
2547	// * @see CCorePlugin#INSERT
2548	// * @see CCorePlugin#DO_NOT_INSERT
2549	// */
2550	// public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_enum_constant"; //$NON-NLS-1$
2551	// /**
2552	// * <pre>
2553	// * FORMATTER / Option to insert a space between empty parenthesis in a method declaration
2554	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_method_declaration"
2555	// * - possible values: { INSERT, DO_NOT_INSERT }
2556	// * - default: DO_NOT_INSERT
2557	// * </pre>
2558	// * @see CCorePlugin#INSERT
2559	// * @see CCorePlugin#DO_NOT_INSERT
2560	// */
2561	// public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_method_declaration"; //$NON-NLS-1$
2562	// /**
2563	// * <pre>
2564	// * FORMATTER / Option to insert a space between empty parenthesis in a method invocation
2565	// * - option id: "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_method_invocation"
2566	// * - possible values: { INSERT, DO_NOT_INSERT }
2567	// * - default: DO_NOT_INSERT
2568	// * </pre>
2569	// * @see CCorePlugin#INSERT
2570	// * @see CCorePlugin#DO_NOT_INSERT
2571	// */
2572	// public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_method_invocation"; //$NON-NLS-1$
2573	// /**
2574	// * <pre>
2575	// * FORMATTER / Option to keep else statement on the same line
2576	// * - option id: "org.eclipse.cdt.core.formatter.keep_else_statement_on_same_line"
2577	// * - possible values: { TRUE, FALSE }
2578	// * - default: FALSE
2579	// * </pre>
2580	// * @see #TRUE
2581	// * @see #FALSE
2582	// */
2583	// public static final String FORMATTER_KEEP_ELSE_STATEMENT_ON_SAME_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_else_statement_on_same_line"; //$NON-NLS-1$
2584	// /**
2585	// * <pre>
2586	// * FORMATTER / Option to keep empty array initializer one one line
2587	// * - option id: "org.eclipse.cdt.core.formatter.keep_empty_array_initializer_on_one_line"
2588	// * - possible values: { TRUE, FALSE }
2589	// * - default: FALSE
2590	// * </pre>
2591	// * @see #TRUE
2592	// * @see #FALSE
2593	// */
2594	// public static final String FORMATTER_KEEP_EMPTY_ARRAY_INITIALIZER_ON_ONE_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_empty_array_initializer_on_one_line"; //$NON-NLS-1$
2595	// /**
2596	// * <pre>
2597	// * FORMATTER / Option to keep guardian clause on one line
2598	// * - option id: "org.eclipse.cdt.core.formatter.format_guardian_clause_on_one_line"
2599	// * - possible values: { TRUE, FALSE }
2600	// * - default: FALSE
2601	// * </pre>
2602	// * @see #TRUE
2603	// * @see #FALSE
2604	// */
2605	// public static final String FORMATTER_KEEP_GUARDIAN_CLAUSE_ON_ONE_LINE = CCorePlugin.PLUGIN_ID + ".formatter.format_guardian_clause_on_one_line"; //$NON-NLS-1$
2606	// /**
2607	// * <pre>
2608	// * FORMATTER / Option to keep simple if statement on the one line
2609	// * - option id: "org.eclipse.cdt.core.formatter.keep_imple_if_on_one_line"
2610	// * - possible values: { TRUE, FALSE }
2611	// * - default: FALSE
2612	// * </pre>
2613	// * @see #TRUE
2614	// * @see #FALSE
2615	// */
2616	// public static final String FORMATTER_KEEP_SIMPLE_IF_ON_ONE_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_imple_if_on_one_line"; //$NON-NLS-1$
2617	// /**
2618	// * <pre>
2619	// * FORMATTER / Option to keep then statement on the same line
2620	// * - option id: "org.eclipse.cdt.core.formatter.keep_then_statement_on_same_line"
2621	// * - possible values: { TRUE, FALSE }
2622	// * - default: FALSE
2623	// * </pre>
2624	// * @see #TRUE
2625	// * @see #FALSE
2626	// */
2627	// public static final String FORMATTER_KEEP_THEN_STATEMENT_ON_SAME_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_then_statement_on_same_line";//$NON-NLS-1$
2628
2629	/**
2630	* <pre>
2631	* FORMATTER / Option to specify the length of the page. Beyond this length, the formatter will try to split the code
2632	* - option id: "org.eclipse.cdt.core.formatter.lineSplit"
2633	* - possible values: "<n>", where n is zero or a positive integer
2634	* - default: "80"
2635	* </pre>
2636	*/
2637	public static final String FORMATTER_LINE_SPLIT = CCorePlugin.PLUGIN_ID + ".formatter.lineSplit"; //$NON-NLS-1$
2638	//
2639	// /**
2640	// * <pre>
2641	// * FORMATTER / Option to specify the number of empty lines to preserve
2642	// * - option id: "org.eclipse.cdt.core.formatter.number_of_empty_lines_to_preserve"
2643	// * - possible values: "<n>", where n is zero or a positive integer
2644	// * - default: "0"
2645	// * </pre>
2646	// */
2647	// public static final String FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE = CCorePlugin.PLUGIN_ID + ".formatter.number_of_empty_lines_to_preserve"; //$NON-NLS-1$
2648	// /**
2649	// * <pre>
2650	// * FORMATTER / Option to specify whether or not empty statement should be on a new line
2651	// * - option id: "org.eclipse.cdt.core.formatter.put_empty_statement_on_new_line"
2652	// * - possible values: { TRUE, FALSE }
2653	// * - default: FALSE
2654	// * </pre>
2655	// * @see #TRUE
2656	// * @see #FALSE
2657	// */
2658	// public static final String FORMATTER_PUT_EMPTY_STATEMENT_ON_NEW_LINE = CCorePlugin.PLUGIN_ID + ".formatter.put_empty_statement_on_new_line"; //$NON-NLS-1$
2659	/**
2660	* <pre>
2661	* FORMATTER / Option to specify the tabulation size
2662	* - option id: "org.eclipse.cdt.core.formatter.tabulation.char"
2663	* - possible values: { TAB, SPACE, MIXED }
2664	* - default: TAB
2665	* </pre>
2666	* More values may be added in the future.
2667	*
2668	* @see CCorePlugin#TAB
2669	* @see CCorePlugin#SPACE
2670	* @see #MIXED
2671	*/
2672	public static final String FORMATTER_TAB_CHAR = CCorePlugin.PLUGIN_ID + ".formatter.tabulation.char"; //$NON-NLS-1$
2673	/**
2674	* <pre>
2675	* FORMATTER / Option to specify the equivalent number of spaces that represents one tabulation
2676	* - option id: "org.eclipse.cdt.core.formatter.tabulation.size"
2677	* - possible values: "<n>", where n is zero or a positive integer
2678	* - default: "4"
2679	* </pre>
2680	*/
2681	public static final String FORMATTER_TAB_SIZE = CCorePlugin.PLUGIN_ID + ".formatter.tabulation.size"; //$NON-NLS-1$
2682
2683	/**
2684	* <pre>
2685	* FORMATTER / Option to use tabulations only for leading indentations
2686	* - option id: "org.eclipse.cdt.core.formatter.use_tabs_only_for_leading_indentations"
2687	* - possible values: { TRUE, FALSE }
2688	* - default: FALSE
2689	* </pre>
2690	* @see #TRUE
2691	* @see #FALSE
2692	*/
2693	public static final String FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS = CCorePlugin.PLUGIN_ID + ".formatter.use_tabs_only_for_leading_indentations"; //$NON-NLS-1$
2694
2695	/**
2696	* <pre>
2697	* FORMATTER / The wrapping is done by indenting by one compare to the current indentation.
2698	* </pre>
2699	*/
2700	public static final int INDENT_BY_ONE= 2;
2701
2702	/**
2703	* <pre>
2704	* FORMATTER / The wrapping is done by using the current indentation.
2705	* </pre>
2706	*/
2707	public static final int INDENT_DEFAULT= 0;
2708	/**
2709	* <pre>
2710	* FORMATTER / The wrapping is done by indenting on column under the splitting location.
2711	* </pre>
2712	*/
2713	public static final int INDENT_ON_COLUMN = 1;
2714
2715	/**
2716	* <pre>
2717	* FORMATTER / Possible value for the option FORMATTER_TAB_CHAR
2718	* </pre>
2719	* @see CCorePlugin#TAB
2720	* @see CCorePlugin#SPACE
2721	* @see #FORMATTER_TAB_CHAR
2722	*/
2723	public static final String MIXED = "mixed"; //$NON-NLS-1$
2724	// /**
2725	// * <pre>
2726	// * FORMATTER / Value to set a brace location at the start of the next line with
2727	// * the right indentation.
2728	// * </pre>
2729	// * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
2730	// * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
2731	// * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
2732	// * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
2733	// * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
2734	// * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
2735	// * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
2736	// */
2737	// public static final String NEXT_LINE = "next_line"; //$NON-NLS-1$
2738	// /**
2739	// * <pre>
2740	// * FORMATTER / Value to set a brace location at the start of the next line if a wrapping
2741	// * occured.
2742	// * </pre>
2743	// * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
2744	// * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
2745	// * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
2746	// * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
2747	// * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
2748	// * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
2749	// * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
2750	// */
2751	// public static final String NEXT_LINE_ON_WRAP = "next_line_on_wrap"; //$NON-NLS-1$
2752	/**
2753	* <pre>
2754	* FORMATTER / Value to set a brace location at the start of the next line with
2755	* an extra indentation.
2756	* </pre>
2757	* @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
2758	* @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
2759	* @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
2760	* @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
2761	* @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
2762	* @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
2763	* @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
2764	*/
2765	public static final String NEXT_LINE_SHIFTED = "next_line_shifted"; //$NON-NLS-1$
2766	/**
2767	* <pre>
2768	* FORMATTER / Value to set an option to true.
2769	* </pre>
2770	*/
2771	public static final String TRUE = "true"; //$NON-NLS-1$
2772	/**
2773	* <pre>
2774	* FORMATTER / The wrapping is done using as few lines as possible.
2775	* </pre>
2776	*/
2777	public static final int WRAP_COMPACT= 1;
2778	/**
2779	* <pre>
2780	* FORMATTER / The wrapping is done putting the first element on a new
2781	* line and then wrapping next elements using as few lines as possible.
2782	* </pre>
2783	*/
2784	public static final int WRAP_COMPACT_FIRST_BREAK= 2;
2785	/**
2786	* <pre>
2787	* FORMATTER / The wrapping is done by putting each element on its own line
2788	* except the first element.
2789	* </pre>
2790	*/
2791	public static final int WRAP_NEXT_PER_LINE= 5;
2792	/**
2793	* <pre>
2794	* FORMATTER / The wrapping is done by putting each element on its own line.
2795	* All elements are indented by one except the first element.
2796	* </pre>
2797	*/
2798	public static final int WRAP_NEXT_SHIFTED= 4;
2799
2800	/**
2801	* <pre>
2802	* FORMATTER / Value to disable alignment.
2803	* </pre>
2804	*/
2805	public static final int WRAP_NO_SPLIT= 0;
2806	/**
2807	* <pre>
2808	* FORMATTER / The wrapping is done by putting each element on its own line.
2809	* </pre>
2810	*/
2811	public static final int WRAP_ONE_PER_LINE= 3;
2812
2813	/*
2814	* Private constants.
2815	*/
2816	private static final IllegalArgumentException WRONG_ARGUMENT = new IllegalArgumentException();
2817
2818	/**
2819	* Create a new alignment value according to the given values. This must be used to set up
2820	* the alignment options.
2821	*
2822	* @param forceSplit the given force value
2823	* @param wrapStyle the given wrapping style
2824	* @param indentStyle the given indent style
2825	*
2826	* @return the new alignement value
2827	*/
2828	public static String createAlignmentValue(boolean forceSplit, int wrapStyle, int indentStyle) {
2829	int alignmentValue = 0;
2830	switch(wrapStyle) {
2831	case WRAP_COMPACT :
2832	alignmentValue \|= Alignment.M_COMPACT_SPLIT;
2833	break;
2834	case WRAP_COMPACT_FIRST_BREAK :
2835	alignmentValue \|= Alignment.M_COMPACT_FIRST_BREAK_SPLIT;
2836	break;
2837	case WRAP_NEXT_PER_LINE :
2838	alignmentValue \|= Alignment.M_NEXT_PER_LINE_SPLIT;
2839	break;
2840	case WRAP_NEXT_SHIFTED :
2841	alignmentValue \|= Alignment.M_NEXT_SHIFTED_SPLIT;
2842	break;
2843	case WRAP_ONE_PER_LINE :
2844	alignmentValue \|= Alignment.M_ONE_PER_LINE_SPLIT;
2845	break;
2846	}
2847	if (forceSplit) {
2848	alignmentValue \|= Alignment.M_FORCE;
2849	}
2850	switch(indentStyle) {
2851	case INDENT_BY_ONE :
2852	alignmentValue \|= Alignment.M_INDENT_BY_ONE;
2853	break;
2854	case INDENT_ON_COLUMN :
2855	alignmentValue \|= Alignment.M_INDENT_ON_COLUMN;
2856	}
2857	return String.valueOf(alignmentValue);
2858	}
2859
2860	/**
2861	* Returns the default Eclipse formatter settings
2862	*
2863	* @return the Eclipse default settings
2864	*/
2865	public static Map getEclipseDefaultSettings() {
2866	return DefaultCodeFormatterOptions.getEclipseDefaultSettings().getMap();
2867	}
2868
2869	/**
2870	* <p>Return the force value of the given alignment value.
2871	* The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
2872	* API.
2873	* </p>
2874	*
2875	* @param value the given alignment value
2876	* @return the force value of the given alignment value
2877	* @see #createAlignmentValue(boolean, int, int)
2878	* @exception IllegalArgumentException if the given alignment value is null, or if it
2879	* doesn't have a valid format.
2880	*/
2881	public static boolean getForceWrapping(String value) {
2882	if (value == null) {
2883	throw WRONG_ARGUMENT;
2884	}
2885	try {
2886	int existingValue = Integer.parseInt(value);
2887	return (existingValue & Alignment.M_FORCE) != 0;
2888	} catch (NumberFormatException e) {
2889	throw WRONG_ARGUMENT;
2890	}
2891	}
40		2892
		2893	/**
		2894	* <p>Return the indentation style of the given alignment value.
		2895	* The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
		2896	* API.
		2897	* </p>
		2898	*
		2899	* @param value the given alignment value
		2900	* @return the indentation style of the given alignment value
		2901	* @see #createAlignmentValue(boolean, int, int)
		2902	* @exception IllegalArgumentException if the given alignment value is null, or if it
		2903	* doesn't have a valid format.
		2904	*/
		2905	public static int getIndentStyle(String value) {
		2906	if (value == null) {
		2907	throw WRONG_ARGUMENT;
		2908	}
		2909	try {
		2910	int existingValue = Integer.parseInt(value);
		2911	if ((existingValue & Alignment.M_INDENT_BY_ONE) != 0) {
		2912	return INDENT_BY_ONE;
		2913	} else if ((existingValue & Alignment.M_INDENT_ON_COLUMN) != 0) {
		2914	return INDENT_ON_COLUMN;
		2915	} else {
		2916	return INDENT_DEFAULT;
		2917	}
		2918	} catch (NumberFormatException e) {
		2919	throw WRONG_ARGUMENT;
		2920	}
		2921	}
41		2922
		2923	/**
		2924	* <p>Return the wrapping style of the given alignment value.
		2925	* The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
		2926	* API.
		2927	* </p>
		2928	*
		2929	* @param value the given alignment value
		2930	* @return the wrapping style of the given alignment value
		2931	* @see #createAlignmentValue(boolean, int, int)
		2932	* @exception IllegalArgumentException if the given alignment value is null, or if it
		2933	* doesn't have a valid format.
		2934	*/
		2935	public static int getWrappingStyle(String value) {
		2936	if (value == null) {
		2937	throw WRONG_ARGUMENT;
		2938	}
		2939	try {
		2940	int existingValue = Integer.parseInt(value) & Alignment.SPLIT_MASK;
		2941	switch(existingValue) {
		2942	case Alignment.M_COMPACT_SPLIT :
		2943	return WRAP_COMPACT;
		2944	case Alignment.M_COMPACT_FIRST_BREAK_SPLIT :
		2945	return WRAP_COMPACT_FIRST_BREAK;
		2946	case Alignment.M_NEXT_PER_LINE_SPLIT :
		2947	return WRAP_NEXT_PER_LINE;
		2948	case Alignment.M_NEXT_SHIFTED_SPLIT :
		2949	return WRAP_NEXT_SHIFTED;
		2950	case Alignment.M_ONE_PER_LINE_SPLIT :
		2951	return WRAP_ONE_PER_LINE;
		2952	default:
		2953	return WRAP_NO_SPLIT;
		2954	}
		2955	} catch (NumberFormatException e) {
		2956	throw WRONG_ARGUMENT;
		2957	}
		2958	}
		2959	/**
		2960	* <p>Set the force value of the given alignment value and return the new value.
		2961	* The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
		2962	* API.
		2963	* </p>
		2964	*
		2965	* @param value the given alignment value
		2966	* @param force the given force value
		2967	* @return the new alignment value
		2968	* @see #createAlignmentValue(boolean, int, int)
		2969	* @exception IllegalArgumentException if the given alignment value is null, or if it
		2970	* doesn't have a valid format.
		2971	*/
		2972	public static String setForceWrapping(String value, boolean force) {
		2973	if (value == null) {
		2974	throw WRONG_ARGUMENT;
		2975	}
		2976	try {
		2977	int existingValue = Integer.parseInt(value);
		2978	// clear existing force bit
		2979	existingValue &= ~Alignment.M_FORCE;
		2980	if (force) {
		2981	existingValue \|= Alignment.M_FORCE;
		2982	}
		2983	return String.valueOf(existingValue);
		2984	} catch (NumberFormatException e) {
		2985	throw WRONG_ARGUMENT;
		2986	}
2987	}
2988
2989	/**
2990	* <p>Set the indentation style of the given alignment value and return the new value.
2991	* The given value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
2992	* API.
2993	* </p>
2994	*
2995	* @param value the given alignment value
2996	* @param indentStyle the given indentation style
2997	* @return the new alignment value
2998	* @see #INDENT_BY_ONE
2999	* @see #INDENT_DEFAULT
3000	* @see #INDENT_ON_COLUMN
3001	* @see #createAlignmentValue(boolean, int, int)
3002	* @exception IllegalArgumentException if the given alignment value is null, if the given
3003	* indentation style is not one of the possible indentation styles, or if the given
3004	* alignment value doesn't have a valid format.
3005	*/
3006	public static String setIndentStyle(String value, int indentStyle) {
3007	if (value == null) {
3008	throw WRONG_ARGUMENT;
3009	}
3010	switch(indentStyle) {
3011	case INDENT_BY_ONE :
3012	case INDENT_DEFAULT :
3013	case INDENT_ON_COLUMN :
3014	break;
3015	default :
3016	throw WRONG_ARGUMENT;
3017	}
3018	try {
3019	int existingValue = Integer.parseInt(value);
3020	// clear existing indent bits
3021	existingValue &= ~(Alignment.M_INDENT_BY_ONE \| Alignment.M_INDENT_ON_COLUMN);
3022	switch(indentStyle) {
3023	case INDENT_BY_ONE :
3024	existingValue \|= Alignment.M_INDENT_BY_ONE;
3025	break;
3026	case INDENT_ON_COLUMN :
3027	existingValue \|= Alignment.M_INDENT_ON_COLUMN;
3028	}
3029	return String.valueOf(existingValue);
3030	} catch (NumberFormatException e) {
3031	throw WRONG_ARGUMENT;
3032	}
3033	}
3034	/**
3035	* <p>Set the wrapping style of the given alignment value and return the new value.
3036	* The given value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
3037	* API.
3038	* </p>
3039	*
3040	* @param value the given alignment value
3041	* @param wrappingStyle the given wrapping style
3042	* @return the new alignment value
3043	* @see #WRAP_COMPACT
3044	* @see #WRAP_COMPACT_FIRST_BREAK
3045	* @see #WRAP_NEXT_PER_LINE
3046	* @see #WRAP_NEXT_SHIFTED
3047	* @see #WRAP_NO_SPLIT
3048	* @see #WRAP_ONE_PER_LINE
3049	* @see #createAlignmentValue(boolean, int, int)
3050	* @exception IllegalArgumentException if the given alignment value is null, if the given
3051	* wrapping style is not one of the possible wrapping styles, or if the given
3052	* alignment value doesn't have a valid format.
3053	*/
3054	public static String setWrappingStyle(String value, int wrappingStyle) {
3055	if (value == null) {
3056	throw WRONG_ARGUMENT;
3057	}
3058	switch(wrappingStyle) {
3059	case WRAP_COMPACT :
3060	case WRAP_COMPACT_FIRST_BREAK :
3061	case WRAP_NEXT_PER_LINE :
3062	case WRAP_NEXT_SHIFTED :
3063	case WRAP_NO_SPLIT :
3064	case WRAP_ONE_PER_LINE :
3065	break;
3066	default:
3067	throw WRONG_ARGUMENT;
3068	}
3069	try {
3070	int existingValue = Integer.parseInt(value);
3071	// clear existing split bits
3072	existingValue &= ~(Alignment.SPLIT_MASK);
3073	switch(wrappingStyle) {
3074	case WRAP_COMPACT :
3075	existingValue \|= Alignment.M_COMPACT_SPLIT;
3076	break;
3077	case WRAP_COMPACT_FIRST_BREAK :
3078	existingValue \|= Alignment.M_COMPACT_FIRST_BREAK_SPLIT;
3079	break;
3080	case WRAP_NEXT_PER_LINE :
3081	existingValue \|= Alignment.M_NEXT_PER_LINE_SPLIT;
3082	break;
3083	case WRAP_NEXT_SHIFTED :
3084	existingValue \|= Alignment.M_NEXT_SHIFTED_SPLIT;
3085	break;
3086	case WRAP_ONE_PER_LINE :
3087	existingValue \|= Alignment.M_ONE_PER_LINE_SPLIT;
3088	break;
3089	}
3090	return String.valueOf(existingValue);
3091	} catch (NumberFormatException e) {
3092	throw WRONG_ARGUMENT;
3093	}
3094	}
42	}	3095	}

Lines 7-22 Link Here

(-)src/org/eclipse/cdt/internal/core/CCorePreferenceInitializer.java (-11 / +23 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* QNX Software Systems - Initial API and implementation	9	* QNX Software Systems - Initial API and implementation
		10	* Sergey Prigogin, Google
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.cdt.internal.core;	12	package org.eclipse.cdt.internal.core;
12		13
13	import java.util.HashSet;	14	import java.util.HashSet;
		15	import java.util.Iterator;
		16	import java.util.Map;
14		17
15	import org.eclipse.cdt.core.CCorePlugin;	18	import org.eclipse.cdt.core.CCorePlugin;
16	import org.eclipse.cdt.core.CCorePreferenceConstants;	19	import org.eclipse.cdt.core.CCorePreferenceConstants;
		20	import org.eclipse.cdt.core.formatter.CodeFormatterConstants;
17	import org.eclipse.cdt.internal.core.model.CModelManager;	21	import org.eclipse.cdt.internal.core.model.CModelManager;
18	import org.eclipse.core.runtime.Preferences;	22	//import org.eclipse.core.runtime.Preferences;
19	import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;	23	import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;
		24	import org.eclipse.core.runtime.preferences.DefaultScope;
		25	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
		26	import org.eclipse.core.runtime.preferences.IScopeContext;
20		27
21		28
22	public class CCorePreferenceInitializer extends AbstractPreferenceInitializer {	29	public class CCorePreferenceInitializer extends AbstractPreferenceInitializer {
Lines 25-43 Link Here
25	* @see org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer#initializeDefaultPreferences()	32	* @see org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer#initializeDefaultPreferences()
26	*/	33	*/
27	public void initializeDefaultPreferences() {	34	public void initializeDefaultPreferences() {
28	Preferences preferences = CCorePlugin.getDefault().getPluginPreferences();
29	HashSet optionNames = CModelManager.OptionNames;	35	HashSet optionNames = CModelManager.OptionNames;
30		36
31	// Compiler settings	37	// Formatter settings
32	preferences.setDefault(CCorePreferenceConstants.TRANSLATION_TASK_TAGS, CCorePreferenceConstants.DEFAULT_TASK_TAG);	38	Map defaultOptionsMap = CodeFormatterConstants.getEclipseDefaultSettings(); // code formatter defaults
33	optionNames.add(CCorePreferenceConstants.TRANSLATION_TASK_TAGS);	39
34		40	// Compiler settings
35	preferences.setDefault(CCorePreferenceConstants.TRANSLATION_TASK_PRIORITIES, CCorePreferenceConstants.DEFAULT_TASK_PRIORITY);	41	defaultOptionsMap.put(CCorePreferenceConstants.TRANSLATION_TASK_TAGS, CCorePreferenceConstants.DEFAULT_TASK_TAG);
36	optionNames.add(CCorePreferenceConstants.TRANSLATION_TASK_PRIORITIES);	42	defaultOptionsMap.put(CCorePreferenceConstants.TRANSLATION_TASK_PRIORITIES, CCorePreferenceConstants.DEFAULT_TASK_PRIORITY);
37		43	defaultOptionsMap.put(CCorePreferenceConstants.CODE_FORMATTER, CCorePreferenceConstants.DEFAULT_CODE_FORMATTER);
38	preferences.setDefault(CCorePreferenceConstants.CODE_FORMATTER, CCorePreferenceConstants.DEFAULT_CODE_FORMATTER);
39	optionNames.add(CCorePreferenceConstants.CODE_FORMATTER);
40		44
		45	// Store default values to default preferences
		46	IEclipsePreferences defaultPreferences = ((IScopeContext) new DefaultScope()).getNode(CCorePlugin.PLUGIN_ID);
		47	for (Iterator iter = defaultOptionsMap.entrySet().iterator(); iter.hasNext();) {
		48	Map.Entry entry = (Map.Entry) iter.next();
		49	String optionName = (String) entry.getKey();
		50	defaultPreferences.put(optionName, (String)entry.getValue());
		51	optionNames.add(optionName);
		52	}
41	}	53	}
42		54
43	}	55	}




/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.formatter.align;


/**
 * Alignment management
 */
public class Alignment {

	// name of alignment
	public String name;
	
	// link to enclosing alignment
	public Alignment enclosing;
	 
	// indentation management
	public int fragmentIndex;
	public int fragmentCount;
	public int[] fragmentIndentations;
	public boolean needRedoColumnAlignment;

	// chunk management
	public int chunkStartIndex;
	public int chunkKind;

	// break management	
	public int originalIndentationLevel;
	public int breakIndentationLevel;
	public int shiftBreakIndentationLevel;
	public int[] fragmentBreaks;
	public boolean wasSplit;

	/* 
	 * Alignment modes
	 */
	public static final int M_FORCE = 1; // if bit set, then alignment will be non-optional (default is optional)
	public static final int M_INDENT_ON_COLUMN = 2; // if bit set, broken fragments will be aligned on current location column (default is to break at current indentation level)
	public static final int	M_INDENT_BY_ONE = 4; // if bit set, broken fragments will be indented one level below current (not using continuation indentation)

	// split modes can be combined either with M_FORCE or M_INDENT_ON_COLUMN
	
	/** foobar(#fragment1, #fragment2, <ul>
	 *  <li>    #fragment3, #fragment4 </li>
	 * </ul>
	 */
	public static final int M_COMPACT_SPLIT = 16; // fill each line with all possible fragments

	/** foobar(<ul>
	 * <li>    #fragment1, #fragment2,  </li>
	 * <li>     #fragment5, #fragment4, </li>
	 * </ul>
	 */
	public static final int M_COMPACT_FIRST_BREAK_SPLIT = 32; //  compact mode, but will first try to break before first fragment

	/** foobar(<ul>
	 * <li>     #fragment1,  </li>
	 * <li>     #fragment2,  </li>
	 * <li>     #fragment3 </li>
	 * <li>     #fragment4,  </li>
	 * </ul>
	 */
	public static final int M_ONE_PER_LINE_SPLIT = 32+16; // one fragment per line

	/** 
	 * foobar(<ul>
	 * <li>     #fragment1,  </li>
	 * <li>        #fragment2,  </li>
	 * <li>        #fragment3 </li>
	 * <li>        #fragment4,  </li>
	 * </ul>
	 */ 
	public static final int M_NEXT_SHIFTED_SPLIT = 64; // one fragment per line, subsequent are indented further

	/** foobar(#fragment1, <ul>
	 * <li>      #fragment2,  </li>
	 * <li>      #fragment3 </li>
	 * <li>      #fragment4,  </li>
	 * </ul>
	 */
	public static final int M_NEXT_PER_LINE_SPLIT = 64+16; // one per line, except first fragment (if possible)

	//64+32
	//64+32+16
	
	// mode controlling column alignments
	/** 
	 * <table BORDER COLS=4 WIDTH="100%" >
	 * <tr><td>#fragment1A</td>            <td>#fragment2A</td>       <td>#fragment3A</td>  <td>#very-long-fragment4A</td></tr>
	 * <tr><td>#fragment1B</td>            <td>#long-fragment2B</td>  <td>#fragment3B</td>  <td>#fragment4B</td></tr>
	 * <tr><td>#very-long-fragment1C</td>  <td>#fragment2C</td>       <td>#fragment3C</td>  <td>#fragment4C</td></tr>
	 * </table>
	 */
	public static final int M_MULTICOLUMN = 256; // fragments are on same line, but multiple line of fragments will be aligned vertically
	
	public static final int M_NO_ALIGNMENT = 0;
	
	public int mode;
	
	public static final int SPLIT_MASK = M_ONE_PER_LINE_SPLIT | M_NEXT_SHIFTED_SPLIT | M_COMPACT_SPLIT | M_COMPACT_FIRST_BREAK_SPLIT | M_NEXT_PER_LINE_SPLIT;

	// alignment tie-break rules - when split is needed, will decide whether innermost/outermost alignment is to be chosen
	public static final int R_OUTERMOST = 1;
	public static final int R_INNERMOST = 2;
	public int tieBreakRule;
	
	// alignment effects on a per fragment basis
	public static int NONE = 0;
	public static int BREAK = 1;
	
	// chunk kind
	public static final int CHUNK_FIELD = 1;
	public static final int CHUNK_METHOD = 2;
	public static final int CHUNK_TYPE = 3;
	public static final int CHUNK_ENUM = 4;
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.formatter;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.cdt.core.formatter.CodeFormatterConstants;
import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.internal.formatter.align.Alignment;


public class DefaultCodeFormatterOptions {
	public static final int TAB = 1;
	public static final int SPACE = 2;
	public static final int MIXED = 4;
	
	public static DefaultCodeFormatterOptions getDefaultSettings() {
		DefaultCodeFormatterOptions options = new DefaultCodeFormatterOptions();
		options.setDefaultSettings();
		return options;
	}
	
	public static DefaultCodeFormatterOptions getEclipseDefaultSettings() {
		DefaultCodeFormatterOptions options = new DefaultCodeFormatterOptions();
		options.setEclipseDefaultSettings();
		return options;
	}

	public int alignment_for_arguments_in_allocation_expression;
	public int alignment_for_arguments_in_enum_constant;
	public int alignment_for_arguments_in_explicit_constructor_call;
	public int alignment_for_arguments_in_method_invocation;
	public int alignment_for_arguments_in_qualified_allocation_expression;
	public int alignment_for_assignment;
	public int alignment_for_binary_expression;
	public int alignment_for_compact_if;
	public int alignment_for_conditional_expression;
	public int alignment_for_enum_constants;
	public int alignment_for_expressions_in_array_initializer;
	public int alignment_for_multiple_fields;
	public int alignment_for_parameters_in_constructor_declaration;
	public int alignment_for_parameters_in_method_declaration;
	public int alignment_for_selector_in_method_invocation;
	public int alignment_for_superclass_in_type_declaration;
	public int alignment_for_superinterfaces_in_enum_declaration;
	public int alignment_for_superinterfaces_in_type_declaration;
	public int alignment_for_throws_clause_in_constructor_declaration;
	public int alignment_for_throws_clause_in_method_declaration;
	
	public boolean align_type_members_on_columns;
	
	public String brace_position_for_array_initializer;
	public String brace_position_for_block;
	public String brace_position_for_block_in_case;
	public String brace_position_for_constructor_declaration;
	public String brace_position_for_enum_constant;
	public String brace_position_for_enum_declaration;
	public String brace_position_for_method_declaration;
	public String brace_position_for_type_declaration;
	public String brace_position_for_switch;
	
	public int continuation_indentation;
	public int continuation_indentation_for_array_initializer;
	
//	public int blank_lines_after_imports;
//	public int blank_lines_after_package;
//	public int blank_lines_before_field;
//	public int blank_lines_before_first_class_body_declaration;
//	public int blank_lines_before_imports;
//	public int blank_lines_before_member_type;
//	public int blank_lines_before_method;
//	public int blank_lines_before_new_chunk;
//	public int blank_lines_before_package;
//	public int blank_lines_between_type_declarations;
//	public int blank_lines_at_beginning_of_method_body;
	
//	public boolean comment_clear_blank_lines;
//	public boolean comment_format;
//	public boolean comment_format_header;
//	public boolean comment_format_html;
//	public boolean comment_format_source;
//	public int comment_line_length;
	
	public boolean indent_statements_compare_to_block;
	public boolean indent_statements_compare_to_body;
	public boolean indent_body_declarations_compare_to_enum_constant_header;
	public boolean indent_body_declarations_compare_to_enum_declaration_header;
	public boolean indent_body_declarations_compare_to_type_header;
	public boolean indent_breaks_compare_to_cases;
	public boolean indent_empty_lines;
	public boolean indent_switchstatements_compare_to_cases;
	public boolean indent_switchstatements_compare_to_switch;
	public int indentation_size;

//	public boolean insert_new_line_after_opening_brace_in_array_initializer;
//	public boolean insert_new_line_at_end_of_file_if_missing;
//	public boolean insert_new_line_before_catch_in_try_statement;
//	public boolean insert_new_line_before_closing_brace_in_array_initializer;
//	public boolean insert_new_line_before_else_in_if_statement;
//	public boolean insert_new_line_before_finally_in_try_statement;
//	public boolean insert_new_line_before_while_in_do_statement;
//	public boolean insert_new_line_in_empty_block;
//	public boolean insert_new_line_in_empty_enum_constant;
//	public boolean insert_new_line_in_empty_enum_declaration;
//	public boolean insert_new_line_in_empty_method_body;
//	public boolean insert_new_line_in_empty_type_declaration;
//	public boolean insert_space_after_and_in_type_parameter;
//	public boolean insert_space_after_assignment_operator;
//	public boolean insert_space_after_binary_operator;
//	public boolean insert_space_after_closing_angle_bracket_in_type_arguments;
//	public boolean insert_space_after_closing_angle_bracket_in_type_parameters;
//	public boolean insert_space_after_closing_paren_in_cast;
//	public boolean insert_space_after_closing_brace_in_block;
//	public boolean insert_space_after_colon_in_assert;
//	public boolean insert_space_after_colon_in_case;
//	public boolean insert_space_after_colon_in_conditional;
//	public boolean insert_space_after_colon_in_for;
//	public boolean insert_space_after_colon_in_labeled_statement;
//	public boolean insert_space_after_comma_in_allocation_expression;
//	public boolean insert_space_after_comma_in_array_initializer;
//	public boolean insert_space_after_comma_in_constructor_declaration_parameters;
//	public boolean insert_space_after_comma_in_constructor_declaration_throws;
//	public boolean insert_space_after_comma_in_enum_constant_arguments;
//	public boolean insert_space_after_comma_in_enum_declarations;
//	public boolean insert_space_after_comma_in_explicit_constructor_call_arguments;
//	public boolean insert_space_after_comma_in_for_increments;
//	public boolean insert_space_after_comma_in_for_inits;
//	public boolean insert_space_after_comma_in_method_invocation_arguments;
//	public boolean insert_space_after_comma_in_method_declaration_parameters;
//	public boolean insert_space_after_comma_in_method_declaration_throws;
//	public boolean insert_space_after_comma_in_multiple_field_declarations;
//	public boolean insert_space_after_comma_in_multiple_local_declarations;
//	public boolean insert_space_after_comma_in_parameterized_type_reference;
//	public boolean insert_space_after_comma_in_superinterfaces;
//	public boolean insert_space_after_comma_in_type_arguments;
//	public boolean insert_space_after_comma_in_type_parameters;
//	public boolean insert_space_after_ellipsis;
//	public boolean insert_space_after_opening_angle_bracket_in_parameterized_type_reference;
//	public boolean insert_space_after_opening_angle_bracket_in_type_arguments;
//	public boolean insert_space_after_opening_angle_bracket_in_type_parameters;
//	public boolean insert_space_after_opening_bracket_in_array_allocation_expression;
//	public boolean insert_space_after_opening_bracket_in_array_reference;
//	public boolean insert_space_after_opening_brace_in_array_initializer;
//	public boolean insert_space_after_opening_paren_in_cast;
//	public boolean insert_space_after_opening_paren_in_catch;
//	public boolean insert_space_after_opening_paren_in_constructor_declaration;
//	public boolean insert_space_after_opening_paren_in_enum_constant;
//	public boolean insert_space_after_opening_paren_in_for;
//	public boolean insert_space_after_opening_paren_in_if;
//	public boolean insert_space_after_opening_paren_in_method_declaration;
//	public boolean insert_space_after_opening_paren_in_method_invocation;
//	public boolean insert_space_after_opening_paren_in_parenthesized_expression;
//	public boolean insert_space_after_opening_paren_in_switch;
//	public boolean insert_space_after_opening_paren_in_synchronized;
//	public boolean insert_space_after_opening_paren_in_while;
//	public boolean insert_space_after_postfix_operator;
//	public boolean insert_space_after_prefix_operator;
//	public boolean insert_space_after_question_in_conditional;
//	public boolean insert_space_after_question_in_wilcard;
//	public boolean insert_space_after_semicolon_in_for;
//	public boolean insert_space_after_unary_operator;
//	public boolean insert_space_before_and_in_type_parameter;
//	public boolean insert_space_before_assignment_operator;
//	public boolean insert_space_before_binary_operator;
//	public boolean insert_space_before_closing_angle_bracket_in_parameterized_type_reference;
//	public boolean insert_space_before_closing_angle_bracket_in_type_arguments;
//	public boolean insert_space_before_closing_angle_bracket_in_type_parameters;
//	public boolean insert_space_before_closing_brace_in_array_initializer;
//	public boolean insert_space_before_closing_bracket_in_array_allocation_expression;
//	public boolean insert_space_before_closing_bracket_in_array_reference;
//	public boolean insert_space_before_closing_paren_in_cast;
//	public boolean insert_space_before_closing_paren_in_catch;
//	public boolean insert_space_before_closing_paren_in_constructor_declaration;
//	public boolean insert_space_before_closing_paren_in_enum_constant;
//	public boolean insert_space_before_closing_paren_in_for;
//	public boolean insert_space_before_closing_paren_in_if;
//	public boolean insert_space_before_closing_paren_in_method_declaration;
//	public boolean insert_space_before_closing_paren_in_method_invocation;
//	public boolean insert_space_before_closing_paren_in_parenthesized_expression;
//	public boolean insert_space_before_closing_paren_in_switch;
//	public boolean insert_space_before_closing_paren_in_synchronized;
//	public boolean insert_space_before_closing_paren_in_while;
//	public boolean insert_space_before_colon_in_assert;
//	public boolean insert_space_before_colon_in_case;
//	public boolean insert_space_before_colon_in_conditional;
//	public boolean insert_space_before_colon_in_default;
//	public boolean insert_space_before_colon_in_for;
//	public boolean insert_space_before_colon_in_labeled_statement;
//	public boolean insert_space_before_comma_in_allocation_expression;
//	public boolean insert_space_before_comma_in_array_initializer;
//	public boolean insert_space_before_comma_in_constructor_declaration_parameters;
//	public boolean insert_space_before_comma_in_constructor_declaration_throws;
//	public boolean insert_space_before_comma_in_enum_constant_arguments;
//	public boolean insert_space_before_comma_in_enum_declarations;
//	public boolean insert_space_before_comma_in_explicit_constructor_call_arguments;
//	public boolean insert_space_before_comma_in_for_increments;
//	public boolean insert_space_before_comma_in_for_inits;
//	public boolean insert_space_before_comma_in_method_invocation_arguments;
//	public boolean insert_space_before_comma_in_method_declaration_parameters;
//	public boolean insert_space_before_comma_in_method_declaration_throws;
//	public boolean insert_space_before_comma_in_multiple_field_declarations;
//	public boolean insert_space_before_comma_in_multiple_local_declarations;
//	public boolean insert_space_before_comma_in_parameterized_type_reference;
//	public boolean insert_space_before_comma_in_superinterfaces;
//	public boolean insert_space_before_comma_in_type_arguments;
//	public boolean insert_space_before_comma_in_type_parameters;
//	public boolean insert_space_before_ellipsis;
//	public boolean insert_space_before_parenthesized_expression_in_return;
//	public boolean insert_space_before_question_in_wilcard;
//	public boolean insert_space_before_opening_angle_bracket_in_parameterized_type_reference;
//	public boolean insert_space_before_opening_angle_bracket_in_type_arguments;
//	public boolean insert_space_before_opening_angle_bracket_in_type_parameters;
//	public boolean insert_space_before_opening_brace_in_array_initializer;
//	public boolean insert_space_before_opening_brace_in_block;
//	public boolean insert_space_before_opening_brace_in_constructor_declaration;
//	public boolean insert_space_before_opening_brace_in_enum_constant;
//	public boolean insert_space_before_opening_brace_in_enum_declaration;
//	public boolean insert_space_before_opening_brace_in_method_declaration;
//	public boolean insert_space_before_opening_brace_in_type_declaration;
//	public boolean insert_space_before_opening_bracket_in_array_allocation_expression;
//	public boolean insert_space_before_opening_bracket_in_array_reference;
//	public boolean insert_space_before_opening_bracket_in_array_type_reference;
//	public boolean insert_space_before_opening_paren_in_catch;
//	public boolean insert_space_before_opening_paren_in_constructor_declaration;
//	public boolean insert_space_before_opening_paren_in_enum_constant;
//	public boolean insert_space_before_opening_paren_in_for;
//	public boolean insert_space_before_opening_paren_in_if;
//	public boolean insert_space_before_opening_paren_in_method_invocation;
//	public boolean insert_space_before_opening_paren_in_method_declaration;
//	public boolean insert_space_before_opening_paren_in_switch;
//	public boolean insert_space_before_opening_brace_in_switch;
//	public boolean insert_space_before_opening_paren_in_synchronized;
//	public boolean insert_space_before_opening_paren_in_parenthesized_expression;
//	public boolean insert_space_before_opening_paren_in_while;
//	public boolean insert_space_before_postfix_operator;
//	public boolean insert_space_before_prefix_operator;
//	public boolean insert_space_before_question_in_conditional;
//	public boolean insert_space_before_semicolon;
//	public boolean insert_space_before_semicolon_in_for;
//	public boolean insert_space_before_unary_operator;
//	public boolean insert_space_between_brackets_in_array_type_reference;
//	public boolean insert_space_between_empty_braces_in_array_initializer;
//	public boolean insert_space_between_empty_brackets_in_array_allocation_expression;
//	public boolean insert_space_between_empty_parens_in_constructor_declaration;
//	public boolean insert_space_between_empty_parens_in_enum_constant;
//	public boolean insert_space_between_empty_parens_in_method_declaration;
//	public boolean insert_space_between_empty_parens_in_method_invocation;
//	public boolean compact_else_if;
//	public boolean keep_guardian_clause_on_one_line;
//	public boolean keep_else_statement_on_same_line;
//	public boolean keep_empty_array_initializer_on_one_line;
//	public boolean keep_simple_if_on_one_line;
//	public boolean keep_then_statement_on_same_line;
//	public int number_of_empty_lines_to_preserve;
//	public boolean put_empty_statement_on_new_line;
	public int tab_size;
	public final char filling_space = ' ';
	public int page_width;
	public int tab_char = TAB;
	public boolean use_tabs_only_for_leading_indentations;
	
	public int initial_indentation_level;
	public String line_separator;
	
	private DefaultCodeFormatterOptions() {
		// cannot be instantiated
	}

	public DefaultCodeFormatterOptions(Map settings) {
		setDefaultSettings();
		if (settings == null) return;
		set(settings);
	}

	private String getAlignment(int alignment) {
		return Integer.toString(alignment);
	}

	public Map getMap() {
		Map options = new HashMap();
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ALLOCATION_EXPRESSION, getAlignment(this.alignment_for_arguments_in_allocation_expression));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ENUM_CONSTANT, getAlignment(this.alignment_for_arguments_in_enum_constant));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_EXPLICIT_CONSTRUCTOR_CALL, getAlignment(this.alignment_for_arguments_in_explicit_constructor_call));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION, getAlignment(this.alignment_for_arguments_in_method_invocation));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_QUALIFIED_ALLOCATION_EXPRESSION, getAlignment(this.alignment_for_arguments_in_qualified_allocation_expression));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ASSIGNMENT, getAlignment(this.alignment_for_assignment));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_BINARY_EXPRESSION, getAlignment(this.alignment_for_binary_expression));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_COMPACT_IF, getAlignment(this.alignment_for_compact_if));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION, getAlignment(this.alignment_for_conditional_expression));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ENUM_CONSTANTS, getAlignment(this.alignment_for_enum_constants));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER, getAlignment(this.alignment_for_expressions_in_array_initializer));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_MULTIPLE_FIELDS, getAlignment(this.alignment_for_multiple_fields));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_CONSTRUCTOR_DECLARATION, getAlignment(this.alignment_for_parameters_in_constructor_declaration));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION, getAlignment(this.alignment_for_parameters_in_method_declaration));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SELECTOR_IN_METHOD_INVOCATION, getAlignment(this.alignment_for_selector_in_method_invocation));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERCLASS_IN_TYPE_DECLARATION, getAlignment(this.alignment_for_superclass_in_type_declaration));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_ENUM_DECLARATION, getAlignment(this.alignment_for_superinterfaces_in_enum_declaration));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_TYPE_DECLARATION, getAlignment(this.alignment_for_superinterfaces_in_type_declaration));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_CONSTRUCTOR_DECLARATION, getAlignment(this.alignment_for_throws_clause_in_constructor_declaration));
		options.put(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_METHOD_DECLARATION, getAlignment(this.alignment_for_throws_clause_in_method_declaration));
		options.put(CodeFormatterConstants.FORMATTER_ALIGN_TYPE_MEMBERS_ON_COLUMNS, this.align_type_members_on_columns ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
		options.put(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER, this.brace_position_for_array_initializer);
		options.put(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK, this.brace_position_for_block);
		options.put(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK_IN_CASE, this.brace_position_for_block_in_case);
		options.put(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION, this.brace_position_for_constructor_declaration);
		options.put(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ENUM_CONSTANT, this.brace_position_for_enum_constant);
		options.put(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ENUM_DECLARATION, this.brace_position_for_enum_declaration);
		options.put(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION, this.brace_position_for_method_declaration);
		options.put(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION, this.brace_position_for_type_declaration);
		options.put(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_SWITCH, this.brace_position_for_switch);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_CLEAR_BLANK_LINES, this.comment_clear_blank_lines ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT, this.comment_format ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT_HEADER, this.comment_format_header ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT_HTML, this.comment_format_html ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT_SOURCE, this.comment_format_source ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, Integer.toString(this.comment_line_length));
		options.put(CodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION, Integer.toString(this.continuation_indentation));
		options.put(CodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION_FOR_ARRAY_INITIALIZER, Integer.toString(this.continuation_indentation_for_array_initializer));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_AFTER_IMPORTS, Integer.toString(this.blank_lines_after_imports));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_AFTER_PACKAGE, Integer.toString(this.blank_lines_after_package));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_FIELD, Integer.toString(this.blank_lines_before_field));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_FIRST_CLASS_BODY_DECLARATION, Integer.toString(this.blank_lines_before_first_class_body_declaration));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_IMPORTS, Integer.toString(this.blank_lines_before_imports));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_MEMBER_TYPE, Integer.toString(this.blank_lines_before_member_type));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_METHOD, Integer.toString(this.blank_lines_before_method));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_NEW_CHUNK, Integer.toString(this.blank_lines_before_new_chunk));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_PACKAGE, Integer.toString(this.blank_lines_before_package));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_BETWEEN_TYPE_DECLARATIONS, Integer.toString(this.blank_lines_between_type_declarations));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_AT_BEGINNING_OF_METHOD_BODY, Integer.toString(this.blank_lines_at_beginning_of_method_body));
		options.put(CodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK, this.indent_statements_compare_to_block ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
		options.put(CodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY, this.indent_statements_compare_to_body ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
		options.put(CodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_CONSTANT_HEADER, this.indent_body_declarations_compare_to_enum_constant_header ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
		options.put(CodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_DECLARATION_HEADER, this.indent_body_declarations_compare_to_enum_declaration_header ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
		options.put(CodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_TYPE_HEADER, this.indent_body_declarations_compare_to_type_header ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
		options.put(CodeFormatterConstants.FORMATTER_INDENT_BREAKS_COMPARE_TO_CASES, this.indent_breaks_compare_to_cases ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
		options.put(CodeFormatterConstants.FORMATTER_INDENT_EMPTY_LINES, this.indent_empty_lines ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
		options.put(CodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, this.indent_switchstatements_compare_to_cases ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
		options.put(CodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, this.indent_switchstatements_compare_to_switch ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
		options.put(CodeFormatterConstants.FORMATTER_INDENTATION_SIZE, Integer.toString(this.indentation_size));
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER, this.insert_new_line_after_opening_brace_in_array_initializer? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_AT_END_OF_FILE_IF_MISSING, this.insert_new_line_at_end_of_file_if_missing ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT, this.insert_new_line_before_catch_in_try_statement? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER, this.insert_new_line_before_closing_brace_in_array_initializer? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT, this.insert_new_line_before_else_in_if_statement? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_FINALLY_IN_TRY_STATEMENT, this.insert_new_line_before_finally_in_try_statement? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_WHILE_IN_DO_STATEMENT, this.insert_new_line_before_while_in_do_statement? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK, this.insert_new_line_in_empty_block? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_CONSTANT, this.insert_new_line_in_empty_enum_constant? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_DECLARATION, this.insert_new_line_in_empty_enum_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_METHOD_BODY, this.insert_new_line_in_empty_method_body? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_TYPE_DECLARATION, this.insert_new_line_in_empty_type_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_AND_IN_TYPE_PARAMETER, this.insert_space_after_and_in_type_parameter? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_ASSIGNMENT_OPERATOR, this.insert_space_after_assignment_operator? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_BINARY_OPERATOR, this.insert_space_after_binary_operator? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS, this.insert_space_after_closing_angle_bracket_in_type_arguments ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS, this.insert_space_after_closing_angle_bracket_in_type_parameters ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST, this.insert_space_after_closing_paren_in_cast? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_CLOSING_BRACE_IN_BLOCK, this.insert_space_after_closing_brace_in_block? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COLON_IN_ASSERT, this.insert_space_after_colon_in_assert ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CASE, this.insert_space_after_colon_in_case ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CONDITIONAL, this.insert_space_after_colon_in_conditional ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COLON_IN_FOR, this.insert_space_after_colon_in_for ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COLON_IN_LABELED_STATEMENT, this.insert_space_after_colon_in_labeled_statement? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ALLOCATION_EXPRESSION, this.insert_space_after_comma_in_allocation_expression? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ARRAY_INITIALIZER, this.insert_space_after_comma_in_array_initializer? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS, this.insert_space_after_comma_in_constructor_declaration_parameters? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS, this.insert_space_after_comma_in_constructor_declaration_throws? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_CONSTANT_ARGUMENTS, this.insert_space_after_comma_in_enum_constant_arguments ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_DECLARATIONS, this.insert_space_after_comma_in_enum_declarations ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS, this.insert_space_after_comma_in_explicit_constructor_call_arguments? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INCREMENTS, this.insert_space_after_comma_in_for_increments? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INITS, this.insert_space_after_comma_in_for_inits? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_INVOCATION_ARGUMENTS, this.insert_space_after_comma_in_method_invocation_arguments? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_PARAMETERS, this.insert_space_after_comma_in_method_declaration_parameters? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_THROWS, this.insert_space_after_comma_in_method_declaration_throws? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS, this.insert_space_after_comma_in_multiple_field_declarations? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS, this.insert_space_after_comma_in_multiple_local_declarations? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE, this.insert_space_after_comma_in_parameterized_type_reference? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_SUPERINTERFACES, this.insert_space_after_comma_in_superinterfaces? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_ARGUMENTS, this.insert_space_after_comma_in_type_arguments ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_PARAMETERS, this.insert_space_after_comma_in_type_parameters ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION, this.insert_space_after_opening_bracket_in_array_allocation_expression? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_ELLIPSIS, this.insert_space_after_ellipsis ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE, this.insert_space_after_opening_angle_bracket_in_parameterized_type_reference? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS, this.insert_space_after_opening_angle_bracket_in_type_arguments? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS, this.insert_space_after_opening_angle_bracket_in_type_parameters? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_REFERENCE, this.insert_space_after_opening_bracket_in_array_reference? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER, this.insert_space_after_opening_brace_in_array_initializer? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CAST, this.insert_space_after_opening_paren_in_cast? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CATCH, this.insert_space_after_opening_paren_in_catch? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION, this.insert_space_after_opening_paren_in_constructor_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_ENUM_CONSTANT, this.insert_space_after_opening_paren_in_enum_constant? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_FOR, this.insert_space_after_opening_paren_in_for? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_IF, this.insert_space_after_opening_paren_in_if? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_DECLARATION, this.insert_space_after_opening_paren_in_method_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_INVOCATION, this.insert_space_after_opening_paren_in_method_invocation? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION, this.insert_space_after_opening_paren_in_parenthesized_expression? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SWITCH, this.insert_space_after_opening_paren_in_switch? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SYNCHRONIZED, this.insert_space_after_opening_paren_in_synchronized? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_WHILE, this.insert_space_after_opening_paren_in_while? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_POSTFIX_OPERATOR, this.insert_space_after_postfix_operator? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_PREFIX_OPERATOR, this.insert_space_after_prefix_operator? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_CONDITIONAL, this.insert_space_after_question_in_conditional? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_WILDCARD, this.insert_space_after_question_in_wilcard? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_SEMICOLON_IN_FOR, this.insert_space_after_semicolon_in_for? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_UNARY_OPERATOR, this.insert_space_after_unary_operator? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_AND_IN_TYPE_PARAMETER, this.insert_space_before_and_in_type_parameter ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR, this.insert_space_before_assignment_operator? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_BINARY_OPERATOR, this.insert_space_before_binary_operator? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE, this.insert_space_before_closing_angle_bracket_in_parameterized_type_reference? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS, this.insert_space_before_closing_angle_bracket_in_type_arguments? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS, this.insert_space_before_closing_angle_bracket_in_type_parameters? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER, this.insert_space_before_closing_brace_in_array_initializer? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION, this.insert_space_before_closing_bracket_in_array_allocation_expression? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_REFERENCE, this.insert_space_before_closing_bracket_in_array_reference? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CAST, this.insert_space_before_closing_paren_in_cast? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CATCH, this.insert_space_before_closing_paren_in_catch? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CONSTRUCTOR_DECLARATION, this.insert_space_before_closing_paren_in_constructor_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_ENUM_CONSTANT, this.insert_space_before_closing_paren_in_enum_constant? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_FOR, this.insert_space_before_closing_paren_in_for? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_IF, this.insert_space_before_closing_paren_in_if? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_DECLARATION, this.insert_space_before_closing_paren_in_method_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_INVOCATION, this.insert_space_before_closing_paren_in_method_invocation? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_PARENTHESIZED_EXPRESSION, this.insert_space_before_closing_paren_in_parenthesized_expression? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SWITCH, this.insert_space_before_closing_paren_in_switch? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SYNCHRONIZED, this.insert_space_before_closing_paren_in_synchronized? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_WHILE, this.insert_space_before_closing_paren_in_while? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_ASSERT, this.insert_space_before_colon_in_assert? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CASE, this.insert_space_before_colon_in_case? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CONDITIONAL, this.insert_space_before_colon_in_conditional? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_DEFAULT, this.insert_space_before_colon_in_default? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_FOR, this.insert_space_before_colon_in_for ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_LABELED_STATEMENT, this.insert_space_before_colon_in_labeled_statement? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ALLOCATION_EXPRESSION, this.insert_space_before_comma_in_allocation_expression? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ARRAY_INITIALIZER, this.insert_space_before_comma_in_array_initializer? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS, this.insert_space_before_comma_in_constructor_declaration_parameters? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS, this.insert_space_before_comma_in_constructor_declaration_throws? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_CONSTANT_ARGUMENTS, this.insert_space_before_comma_in_enum_constant_arguments? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_DECLARATIONS, this.insert_space_before_comma_in_enum_declarations? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS, this.insert_space_before_comma_in_explicit_constructor_call_arguments? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INCREMENTS, this.insert_space_before_comma_in_for_increments? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INITS, this.insert_space_before_comma_in_for_inits? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_INVOCATION_ARGUMENTS, this.insert_space_before_comma_in_method_invocation_arguments? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_PARAMETERS, this.insert_space_before_comma_in_method_declaration_parameters? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_THROWS, this.insert_space_before_comma_in_method_declaration_throws? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS, this.insert_space_before_comma_in_multiple_field_declarations? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS, this.insert_space_before_comma_in_multiple_local_declarations? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_SUPERINTERFACES, this.insert_space_before_comma_in_superinterfaces? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_ARGUMENTS, this.insert_space_before_comma_in_type_arguments ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_PARAMETERS, this.insert_space_before_comma_in_type_parameters? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE, this.insert_space_before_comma_in_parameterized_type_reference? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_ELLIPSIS, this.insert_space_before_ellipsis ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE, this.insert_space_before_opening_angle_bracket_in_parameterized_type_reference? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS, this.insert_space_before_opening_angle_bracket_in_type_arguments? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS, this.insert_space_before_opening_angle_bracket_in_type_parameters? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ARRAY_INITIALIZER, this.insert_space_before_opening_brace_in_array_initializer? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_BLOCK, this.insert_space_before_opening_brace_in_block? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_CONSTRUCTOR_DECLARATION, this.insert_space_before_opening_brace_in_constructor_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_CONSTANT, this.insert_space_before_opening_brace_in_enum_constant? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_DECLARATION, this.insert_space_before_opening_brace_in_enum_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_METHOD_DECLARATION, this.insert_space_before_opening_brace_in_method_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_TYPE_DECLARATION, this.insert_space_before_opening_brace_in_type_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION, this.insert_space_before_opening_bracket_in_array_allocation_expression ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_REFERENCE, this.insert_space_before_opening_bracket_in_array_reference? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_TYPE_REFERENCE, this.insert_space_before_opening_bracket_in_array_type_reference? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CATCH, this.insert_space_before_opening_paren_in_catch? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION, this.insert_space_before_opening_paren_in_constructor_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ENUM_CONSTANT, this.insert_space_before_opening_paren_in_enum_constant? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_FOR, this.insert_space_before_opening_paren_in_for? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_IF, this.insert_space_before_opening_paren_in_if? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_INVOCATION, this.insert_space_before_opening_paren_in_method_invocation? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_DECLARATION, this.insert_space_before_opening_paren_in_method_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SWITCH, this.insert_space_before_opening_paren_in_switch? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_SWITCH, this.insert_space_before_opening_brace_in_switch? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SYNCHRONIZED, this.insert_space_before_opening_paren_in_synchronized? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION, this.insert_space_before_opening_paren_in_parenthesized_expression? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_WHILE, this.insert_space_before_opening_paren_in_while? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_PARENTHESIZED_EXPRESSION_IN_RETURN, this.insert_space_before_parenthesized_expression_in_return ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_POSTFIX_OPERATOR, this.insert_space_before_postfix_operator? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_PREFIX_OPERATOR, this.insert_space_before_prefix_operator? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_CONDITIONAL, this.insert_space_before_question_in_conditional? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_WILDCARD, this.insert_space_before_question_in_wilcard? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON, this.insert_space_before_semicolon? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON_IN_FOR, this.insert_space_before_semicolon_in_for? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_UNARY_OPERATOR, this.insert_space_before_unary_operator? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_BRACKETS_IN_ARRAY_TYPE_REFERENCE, this.insert_space_between_brackets_in_array_type_reference? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACES_IN_ARRAY_INITIALIZER, this.insert_space_between_empty_braces_in_array_initializer? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACKETS_IN_ARRAY_ALLOCATION_EXPRESSION, this.insert_space_between_empty_brackets_in_array_allocation_expression? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_CONSTRUCTOR_DECLARATION, this.insert_space_between_empty_parens_in_constructor_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_ENUM_CONSTANT, this.insert_space_between_empty_parens_in_enum_constant? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_DECLARATION, this.insert_space_between_empty_parens_in_method_declaration? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_INVOCATION, this.insert_space_between_empty_parens_in_method_invocation? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_COMPACT_ELSE_IF, this.compact_else_if ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_KEEP_GUARDIAN_CLAUSE_ON_ONE_LINE, this.keep_guardian_clause_on_one_line ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_KEEP_ELSE_STATEMENT_ON_SAME_LINE, this.keep_else_statement_on_same_line ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_KEEP_EMPTY_ARRAY_INITIALIZER_ON_ONE_LINE, this.keep_empty_array_initializer_on_one_line ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_KEEP_SIMPLE_IF_ON_ONE_LINE, this.keep_simple_if_on_one_line ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_KEEP_THEN_STATEMENT_ON_SAME_LINE, this.keep_then_statement_on_same_line ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE, Integer.toString(this.number_of_empty_lines_to_preserve));
//		options.put(CodeFormatterConstants.FORMATTER_PUT_EMPTY_STATEMENT_ON_NEW_LINE, this.put_empty_statement_on_new_line ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_LINE_SPLIT, Integer.toString(this.page_width));
		switch(this.tab_char) {
			case SPACE :
				options.put(CodeFormatterConstants.FORMATTER_TAB_CHAR, CCorePlugin.SPACE);
				break;
			case TAB :
				options.put(CodeFormatterConstants.FORMATTER_TAB_CHAR, CCorePlugin.TAB);
				break;
			case MIXED :
				options.put(CodeFormatterConstants.FORMATTER_TAB_CHAR, CodeFormatterConstants.MIXED);
				break;
		}
		options.put(CodeFormatterConstants.FORMATTER_TAB_SIZE, Integer.toString(this.tab_size));
		options.put(CodeFormatterConstants.FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS, this.use_tabs_only_for_leading_indentations ?  CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
		return options;
	}

	public void set(Map settings) {
		final Object alignmentForArgumentsInAllocationExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ALLOCATION_EXPRESSION);
		if (alignmentForArgumentsInAllocationExpressionOption != null) {
			try {
				this.alignment_for_arguments_in_allocation_expression = Integer.parseInt((String) alignmentForArgumentsInAllocationExpressionOption);
			} catch (NumberFormatException e) {
				this.alignment_for_arguments_in_allocation_expression = Alignment.M_COMPACT_SPLIT;
			} catch (ClassCastException e) {
				this.alignment_for_arguments_in_allocation_expression = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForArgumentsInEnumConstantOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ENUM_CONSTANT);
		if (alignmentForArgumentsInEnumConstantOption != null) {
			try {
				this.alignment_for_arguments_in_enum_constant = Integer.parseInt((String) alignmentForArgumentsInEnumConstantOption);
			} catch (NumberFormatException e) {
				this.alignment_for_arguments_in_enum_constant = Alignment.M_COMPACT_SPLIT;
			} catch (ClassCastException e) {
				this.alignment_for_arguments_in_enum_constant = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForArgumentsInExplicitConstructorCallOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_EXPLICIT_CONSTRUCTOR_CALL);
		if (alignmentForArgumentsInExplicitConstructorCallOption != null) {
			try {
				this.alignment_for_arguments_in_explicit_constructor_call = Integer.parseInt((String) alignmentForArgumentsInExplicitConstructorCallOption);
			} catch (NumberFormatException e) {
				this.alignment_for_arguments_in_explicit_constructor_call = Alignment.M_COMPACT_SPLIT;
			} catch (ClassCastException e) {
				this.alignment_for_arguments_in_explicit_constructor_call = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForArgumentsInMethodInvocationOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION);
		if (alignmentForArgumentsInMethodInvocationOption != null) {
			try {
				this.alignment_for_arguments_in_method_invocation = Integer.parseInt((String) alignmentForArgumentsInMethodInvocationOption);
			} catch (NumberFormatException e) {
				this.alignment_for_arguments_in_method_invocation = Alignment.M_COMPACT_SPLIT;
			} catch (ClassCastException e) {
				this.alignment_for_arguments_in_method_invocation = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForArgumentsInQualifiedAllocationExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_QUALIFIED_ALLOCATION_EXPRESSION);
		if (alignmentForArgumentsInQualifiedAllocationExpressionOption != null) {
			try {
				this.alignment_for_arguments_in_qualified_allocation_expression = Integer.parseInt((String) alignmentForArgumentsInQualifiedAllocationExpressionOption);
			} catch (NumberFormatException e) {
				this.alignment_for_arguments_in_qualified_allocation_expression = Alignment.M_COMPACT_SPLIT;
			} catch (ClassCastException e) {
				this.alignment_for_arguments_in_qualified_allocation_expression = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForAssignmentOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ASSIGNMENT);
		if (alignmentForAssignmentOption != null) {
			try {
				this.alignment_for_assignment = Integer.parseInt((String) alignmentForAssignmentOption);
			} catch (NumberFormatException e) {
				this.alignment_for_assignment =  Alignment.M_ONE_PER_LINE_SPLIT;
			} catch (ClassCastException e) {
				this.alignment_for_assignment =  Alignment.M_ONE_PER_LINE_SPLIT;
			}
		}
		final Object alignmentForBinaryExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_BINARY_EXPRESSION);
		if (alignmentForBinaryExpressionOption != null) {
			try {
				this.alignment_for_binary_expression = Integer.parseInt((String) alignmentForBinaryExpressionOption);
			} catch (NumberFormatException e) {
				this.alignment_for_binary_expression =  Alignment.M_COMPACT_SPLIT;
			} catch (ClassCastException e) {
				this.alignment_for_binary_expression =  Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForCompactIfOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_COMPACT_IF);
		if (alignmentForCompactIfOption != null) {
			try {
				this.alignment_for_compact_if = Integer.parseInt((String) alignmentForCompactIfOption);
			} catch (NumberFormatException e) {
				this.alignment_for_compact_if = Alignment.M_ONE_PER_LINE_SPLIT | Alignment.M_INDENT_BY_ONE;
			} catch (ClassCastException e) {
				this.alignment_for_compact_if = Alignment.M_ONE_PER_LINE_SPLIT | Alignment.M_INDENT_BY_ONE;
			}
		}
		final Object alignmentForConditionalExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION);
		if (alignmentForConditionalExpressionOption != null) {
			try {
				this.alignment_for_conditional_expression = Integer.parseInt((String) alignmentForConditionalExpressionOption);
			} catch (NumberFormatException e) {
				this.alignment_for_conditional_expression = Alignment.M_ONE_PER_LINE_SPLIT;
			} catch (ClassCastException e) {
				this.alignment_for_conditional_expression = Alignment.M_ONE_PER_LINE_SPLIT;
			}
		}
		final Object alignmentForEnumConstantsOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ENUM_CONSTANTS);
		if (alignmentForEnumConstantsOption != null) {
			try {
				this.alignment_for_enum_constants = Integer.parseInt((String) alignmentForEnumConstantsOption);
			} catch (NumberFormatException e) {
				this.alignment_for_enum_constants = Alignment.NONE;
			} catch (ClassCastException e) {
				this.alignment_for_enum_constants = Alignment.NONE;
			}
		}
		final Object alignmentForExpressionsInArrayInitializerOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER);
		if (alignmentForExpressionsInArrayInitializerOption != null) {
			try {
				this.alignment_for_expressions_in_array_initializer = Integer.parseInt((String) alignmentForExpressionsInArrayInitializerOption);
			} catch (NumberFormatException e) {
				this.alignment_for_expressions_in_array_initializer = Alignment.M_COMPACT_SPLIT;
			} catch (ClassCastException e) {
				this.alignment_for_expressions_in_array_initializer = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForMultipleFieldsOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_MULTIPLE_FIELDS);
		if (alignmentForMultipleFieldsOption != null) {
			try {
				this.alignment_for_multiple_fields = Integer.parseInt((String) alignmentForMultipleFieldsOption);
			} catch (NumberFormatException e) {
				this.alignment_for_multiple_fields = Alignment.M_COMPACT_SPLIT;
			} catch (ClassCastException e) {
				this.alignment_for_multiple_fields = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForParametersInConstructorDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_CONSTRUCTOR_DECLARATION);
		if (alignmentForParametersInConstructorDeclarationOption != null) {
			try {
				this.alignment_for_parameters_in_constructor_declaration = Integer.parseInt((String) alignmentForParametersInConstructorDeclarationOption);
			} catch (NumberFormatException e) {
				this.alignment_for_parameters_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
			} catch (ClassCastException e) {
				this.alignment_for_parameters_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForParametersInMethodDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION);
		if (alignmentForParametersInMethodDeclarationOption != null) {
			try {
				this.alignment_for_parameters_in_method_declaration = Integer.parseInt((String) alignmentForParametersInMethodDeclarationOption);
			} catch (NumberFormatException e) {
				this.alignment_for_parameters_in_method_declaration = Alignment.M_COMPACT_SPLIT;
			} catch(ClassCastException e) {
				this.alignment_for_parameters_in_method_declaration = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForSelectorInMethodInvocationOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SELECTOR_IN_METHOD_INVOCATION);
		if (alignmentForSelectorInMethodInvocationOption != null) {
			try {
				this.alignment_for_selector_in_method_invocation = Integer.parseInt((String) alignmentForSelectorInMethodInvocationOption);
			} catch (NumberFormatException e) {
				this.alignment_for_selector_in_method_invocation = Alignment.M_COMPACT_SPLIT;
			} catch(ClassCastException e) {
				this.alignment_for_selector_in_method_invocation = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForSuperclassInTypeDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERCLASS_IN_TYPE_DECLARATION);
		if (alignmentForSuperclassInTypeDeclarationOption != null) {
			try {
				this.alignment_for_superclass_in_type_declaration = Integer.parseInt((String) alignmentForSuperclassInTypeDeclarationOption);
			} catch (NumberFormatException e) {
				this.alignment_for_superclass_in_type_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
			} catch(ClassCastException e) {
				this.alignment_for_superclass_in_type_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
			}
		}
		final Object alignmentForSuperinterfacesInEnumDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_ENUM_DECLARATION);
		if (alignmentForSuperinterfacesInEnumDeclarationOption != null) {
			try {
				this.alignment_for_superinterfaces_in_enum_declaration = Integer.parseInt((String) alignmentForSuperinterfacesInEnumDeclarationOption);
			} catch (NumberFormatException e) {
				this.alignment_for_superinterfaces_in_enum_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
			} catch(ClassCastException e) {
				this.alignment_for_superinterfaces_in_enum_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
			}
		}
		final Object alignmentForSuperinterfacesInTypeDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_TYPE_DECLARATION);
		if (alignmentForSuperinterfacesInTypeDeclarationOption != null) {
			try {
				this.alignment_for_superinterfaces_in_type_declaration = Integer.parseInt((String) alignmentForSuperinterfacesInTypeDeclarationOption);
			} catch (NumberFormatException e) {
				this.alignment_for_superinterfaces_in_type_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
			} catch(ClassCastException e) {
				this.alignment_for_superinterfaces_in_type_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
			}
		}
		final Object alignmentForThrowsClauseInConstructorDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_CONSTRUCTOR_DECLARATION);
		if (alignmentForThrowsClauseInConstructorDeclarationOption != null) {
			try {
				this.alignment_for_throws_clause_in_constructor_declaration = Integer.parseInt((String) alignmentForThrowsClauseInConstructorDeclarationOption);
			} catch (NumberFormatException e) {
				this.alignment_for_throws_clause_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
			} catch(ClassCastException e) {
				this.alignment_for_throws_clause_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForThrowsClauseInMethodDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_METHOD_DECLARATION);
		if (alignmentForThrowsClauseInMethodDeclarationOption != null) {
			try {
				this.alignment_for_throws_clause_in_method_declaration = Integer.parseInt((String) alignmentForThrowsClauseInMethodDeclarationOption);
			} catch (NumberFormatException e) {
				this.alignment_for_throws_clause_in_method_declaration = Alignment.M_COMPACT_SPLIT;
			} catch(ClassCastException e) {
				this.alignment_for_throws_clause_in_method_declaration = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignTypeMembersOnColumnsOption = settings.get(CodeFormatterConstants.FORMATTER_ALIGN_TYPE_MEMBERS_ON_COLUMNS);
		if (alignTypeMembersOnColumnsOption != null) {
			this.align_type_members_on_columns = CodeFormatterConstants.TRUE.equals(alignTypeMembersOnColumnsOption);
		}
		final Object bracePositionForArrayInitializerOption = settings.get(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER);
		if (bracePositionForArrayInitializerOption != null) {
			try {
				this.brace_position_for_array_initializer = (String) bracePositionForArrayInitializerOption;
			} catch(ClassCastException e) {
				this.brace_position_for_array_initializer = CodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForBlockOption = settings.get(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK);
		if (bracePositionForBlockOption != null) {
			try {
				this.brace_position_for_block = (String) bracePositionForBlockOption;
			} catch(ClassCastException e) {
				this.brace_position_for_block = CodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForBlockInCaseOption = settings.get(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK_IN_CASE);
		if (bracePositionForBlockInCaseOption != null) {
			try {
				this.brace_position_for_block_in_case = (String) bracePositionForBlockInCaseOption;
			} catch(ClassCastException e) {
				this.brace_position_for_block_in_case = CodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForConstructorDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION);
		if (bracePositionForConstructorDeclarationOption != null) {
			try {
				this.brace_position_for_constructor_declaration = (String) bracePositionForConstructorDeclarationOption;
			} catch(ClassCastException e) {
				this.brace_position_for_constructor_declaration = CodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForEnumConstantOption = settings.get(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ENUM_CONSTANT);
		if (bracePositionForEnumConstantOption != null) {
			try {
				this.brace_position_for_enum_constant = (String) bracePositionForEnumConstantOption;
			} catch(ClassCastException e) {
				this.brace_position_for_enum_constant = CodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForEnumDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ENUM_DECLARATION);
		if (bracePositionForEnumDeclarationOption != null) {
			try {
				this.brace_position_for_enum_declaration = (String) bracePositionForEnumDeclarationOption;
			} catch(ClassCastException e) {
				this.brace_position_for_enum_declaration = CodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForMethodDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION);
		if (bracePositionForMethodDeclarationOption != null) {
			try {
				this.brace_position_for_method_declaration = (String) bracePositionForMethodDeclarationOption;
			} catch(ClassCastException e) {
				this.brace_position_for_method_declaration = CodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForSwitchOption = settings.get(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_SWITCH);
		if (bracePositionForSwitchOption != null) {
			try {
				this.brace_position_for_switch = (String) bracePositionForSwitchOption;
			} catch(ClassCastException e) {
				this.brace_position_for_switch = CodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForTypeDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION);
		if (bracePositionForTypeDeclarationOption != null) {
			try {
				this.brace_position_for_type_declaration = (String) bracePositionForTypeDeclarationOption;
			} catch(ClassCastException e) {
				this.brace_position_for_type_declaration = CodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object continuationIndentationOption = settings.get(CodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION);
		if (continuationIndentationOption != null) {
			try {
				this.continuation_indentation = Integer.parseInt((String) continuationIndentationOption);
			} catch (NumberFormatException e) {
				this.continuation_indentation = 2;
			} catch(ClassCastException e) {
				this.continuation_indentation = 2;
			}
		}
		final Object continuationIndentationForArrayInitializerOption = settings.get(CodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION_FOR_ARRAY_INITIALIZER);
		if (continuationIndentationForArrayInitializerOption != null) {
			try {
				this.continuation_indentation_for_array_initializer = Integer.parseInt((String) continuationIndentationForArrayInitializerOption);
			} catch (NumberFormatException e) {
				this.continuation_indentation_for_array_initializer = 2;
			} catch(ClassCastException e) {
				this.continuation_indentation_for_array_initializer = 2;
			}
		}
//		final Object blankLinesAfterImportsOption = settings.get(CodeFormatterConstants.FORMATTER_BLANK_LINES_AFTER_IMPORTS);
//		if (blankLinesAfterImportsOption != null) {
//			try {
//				this.blank_lines_after_imports = Integer.parseInt((String) blankLinesAfterImportsOption);
//			} catch (NumberFormatException e) {
//				this.blank_lines_after_imports = 0;
//			} catch(ClassCastException e) {
//				this.blank_lines_after_imports = 0;
//			}
//		}
//		final Object blankLinesAfterPackageOption = settings.get(CodeFormatterConstants.FORMATTER_BLANK_LINES_AFTER_PACKAGE);
//		if (blankLinesAfterPackageOption != null) {
//			try {
//				this.blank_lines_after_package = Integer.parseInt((String) blankLinesAfterPackageOption);
//			} catch (NumberFormatException e) {
//				this.blank_lines_after_package = 0;
//			} catch(ClassCastException e) {
//				this.blank_lines_after_package = 0;
//			}
//		}
//		final Object blankLinesBeforeFieldOption = settings.get(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_FIELD);
//		if (blankLinesBeforeFieldOption != null) {
//			try {
//				this.blank_lines_before_field = Integer.parseInt((String) blankLinesBeforeFieldOption);
//			} catch (NumberFormatException e) {
//				this.blank_lines_before_field = 0;
//			} catch(ClassCastException e) {
//				this.blank_lines_before_field = 0;
//			}
//		}
//		final Object blankLinesBeforeFirstClassBodyDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_FIRST_CLASS_BODY_DECLARATION);
//		if (blankLinesBeforeFirstClassBodyDeclarationOption != null) {
//			try {
//				this.blank_lines_before_first_class_body_declaration = Integer.parseInt((String) blankLinesBeforeFirstClassBodyDeclarationOption);
//			} catch (NumberFormatException e) {
//				this.blank_lines_before_first_class_body_declaration = 0;
//			} catch(ClassCastException e) {
//				this.blank_lines_before_first_class_body_declaration = 0;
//			}
//		}
//		final Object blankLinesBeforeImportsOption = settings.get(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_IMPORTS);
//		if (blankLinesBeforeImportsOption != null) {
//			try {
//				this.blank_lines_before_imports = Integer.parseInt((String) blankLinesBeforeImportsOption);
//			} catch (NumberFormatException e) {
//				this.blank_lines_before_imports = 0;
//			} catch(ClassCastException e) {
//				this.blank_lines_before_imports = 0;
//			}
//		}
//		final Object blankLinesBeforeMemberTypeOption = settings.get(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_MEMBER_TYPE);
//		if (blankLinesBeforeMemberTypeOption != null) {
//			try {
//				this.blank_lines_before_member_type = Integer.parseInt((String) blankLinesBeforeMemberTypeOption);
//			} catch (NumberFormatException e) {
//				this.blank_lines_before_member_type = 0;
//			} catch(ClassCastException e) {
//				this.blank_lines_before_member_type = 0;
//			}
//		}
//		final Object blankLinesBeforeMethodOption = settings.get(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_METHOD);
//		if (blankLinesBeforeMethodOption != null) {
//			try {
//				this.blank_lines_before_method = Integer.parseInt((String) blankLinesBeforeMethodOption);
//			} catch (NumberFormatException e) {
//				this.blank_lines_before_method = 0;
//			} catch(ClassCastException e) {
//				this.blank_lines_before_method = 0;
//			}
//		}
//		final Object blankLinesBeforeNewChunkOption = settings.get(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_NEW_CHUNK);
//		if (blankLinesBeforeNewChunkOption != null) {
//			try {
//				this.blank_lines_before_new_chunk = Integer.parseInt((String) blankLinesBeforeNewChunkOption);
//			} catch (NumberFormatException e) {
//				this.blank_lines_before_new_chunk = 0;
//			} catch(ClassCastException e) {
//				this.blank_lines_before_new_chunk = 0;
//			}
//		}
//		final Object blankLinesBeforePackageOption = settings.get(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_PACKAGE);
//		if (blankLinesBeforePackageOption != null) {
//			try {
//				this.blank_lines_before_package = Integer.parseInt((String) blankLinesBeforePackageOption);
//			} catch (NumberFormatException e) {
//				this.blank_lines_before_package = 0;
//			} catch(ClassCastException e) {
//				this.blank_lines_before_package = 0;
//			}
//		}
//		final Object blankLinesBetweenTypeDeclarationsOption = settings.get(CodeFormatterConstants.FORMATTER_BLANK_LINES_BETWEEN_TYPE_DECLARATIONS);
//		if (blankLinesBetweenTypeDeclarationsOption != null) {
//			try {
//				this.blank_lines_between_type_declarations = Integer.parseInt((String) blankLinesBetweenTypeDeclarationsOption);
//			} catch (NumberFormatException e) {
//				this.blank_lines_between_type_declarations = 0;
//			} catch(ClassCastException e) {
//				this.blank_lines_between_type_declarations = 0;
//			}
//		}
//		final Object blankLinesAtBeginningOfMethodBodyOption = settings.get(CodeFormatterConstants.FORMATTER_BLANK_LINES_AT_BEGINNING_OF_METHOD_BODY);
//		if (blankLinesAtBeginningOfMethodBodyOption != null) {
//			try {
//				this.blank_lines_at_beginning_of_method_body = Integer.parseInt((String) blankLinesAtBeginningOfMethodBodyOption);
//			} catch (NumberFormatException e) {
//				this.blank_lines_at_beginning_of_method_body = 0;
//			} catch(ClassCastException e) {
//				this.blank_lines_at_beginning_of_method_body = 0;
//			}
//		}
//		final Object commentClearBlankLinesOption = settings.get(CodeFormatterConstants.FORMATTER_COMMENT_CLEAR_BLANK_LINES);
//		if (commentClearBlankLinesOption != null) {
//			this.comment_clear_blank_lines = CodeFormatterConstants.TRUE.equals(commentClearBlankLinesOption);
//		}
//		final Object commentFormatOption = settings.get(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT);
//		if (commentFormatOption != null) {
//			this.comment_format = CodeFormatterConstants.TRUE.equals(commentFormatOption);
//		}
//		final Object commentFormatHeaderOption = settings.get(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT_HEADER);
//		if (commentFormatHeaderOption != null) {
//			this.comment_format_header = CodeFormatterConstants.TRUE.equals(commentFormatHeaderOption);
//		}
//		final Object commentFormatHtmlOption = settings.get(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT_HTML);
//		if (commentFormatHtmlOption != null) {
//			this.comment_format_html = CodeFormatterConstants.TRUE.equals(commentFormatHtmlOption);
//		}
//		final Object commentFormatSourceOption = settings.get(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT_SOURCE);
//		if (commentFormatSourceOption != null) {
//			this.comment_format_source = CodeFormatterConstants.TRUE.equals(commentFormatSourceOption);
//		}
//		final Object commentLineLengthOption = settings.get(CodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH);
//		if (commentLineLengthOption != null) {
//			try {
//				this.comment_line_length = Integer.parseInt((String) commentLineLengthOption);
//			} catch (NumberFormatException e) {
//				this.comment_line_length = 80;
//			} catch(ClassCastException e) {
//				this.comment_line_length = 80;
//			}
//		}
		final Object indentStatementsCompareToBlockOption = settings.get(CodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK);
		if (indentStatementsCompareToBlockOption != null) {
			this.indent_statements_compare_to_block = CodeFormatterConstants.TRUE.equals(indentStatementsCompareToBlockOption);
		}
		final Object indentStatementsCompareToBodyOption = settings.get(CodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY);
		if (indentStatementsCompareToBodyOption != null) {
			this.indent_statements_compare_to_body = CodeFormatterConstants.TRUE.equals(indentStatementsCompareToBodyOption);
		}
		final Object indentBodyDeclarationsCompareToEnumConstantHeaderOption = settings.get(CodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_CONSTANT_HEADER);
		if (indentBodyDeclarationsCompareToEnumConstantHeaderOption != null) {
			this.indent_body_declarations_compare_to_enum_constant_header = CodeFormatterConstants.TRUE.equals(indentBodyDeclarationsCompareToEnumConstantHeaderOption);
		}
		final Object indentBodyDeclarationsCompareToEnumDeclarationHeaderOption = settings.get(CodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_DECLARATION_HEADER);
		if (indentBodyDeclarationsCompareToEnumDeclarationHeaderOption != null) {
			this.indent_body_declarations_compare_to_enum_declaration_header = CodeFormatterConstants.TRUE.equals(indentBodyDeclarationsCompareToEnumDeclarationHeaderOption);
		}
		final Object indentBodyDeclarationsCompareToTypeHeaderOption = settings.get(CodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_TYPE_HEADER);
		if (indentBodyDeclarationsCompareToTypeHeaderOption != null) {
			this.indent_body_declarations_compare_to_type_header = CodeFormatterConstants.TRUE.equals(indentBodyDeclarationsCompareToTypeHeaderOption);
		}
		final Object indentBreaksCompareToCasesOption = settings.get(CodeFormatterConstants.FORMATTER_INDENT_BREAKS_COMPARE_TO_CASES);
		if (indentBreaksCompareToCasesOption != null) {
			this.indent_breaks_compare_to_cases = CodeFormatterConstants.TRUE.equals(indentBreaksCompareToCasesOption);
		}
		final Object indentEmptyLinesOption = settings.get(CodeFormatterConstants.FORMATTER_INDENT_EMPTY_LINES);
		if (indentEmptyLinesOption != null) {
			this.indent_empty_lines = CodeFormatterConstants.TRUE.equals(indentEmptyLinesOption);
		}
		final Object indentSwitchstatementsCompareToCasesOption = settings.get(CodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES);
		if (indentSwitchstatementsCompareToCasesOption != null) {
			this.indent_switchstatements_compare_to_cases = CodeFormatterConstants.TRUE.equals(indentSwitchstatementsCompareToCasesOption);
		}
		final Object indentSwitchstatementsCompareToSwitchOption = settings.get(CodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH);
		if (indentSwitchstatementsCompareToSwitchOption != null) {
			this.indent_switchstatements_compare_to_switch = CodeFormatterConstants.TRUE.equals(indentSwitchstatementsCompareToSwitchOption);
		}
		final Object indentationSizeOption = settings.get(CodeFormatterConstants.FORMATTER_INDENTATION_SIZE);
		if (indentationSizeOption != null) {
			try {
				this.indentation_size = Integer.parseInt((String) indentationSizeOption);
			} catch (NumberFormatException e) {
				this.indentation_size = 4;
			} catch(ClassCastException e) {
				this.indentation_size = 4;
			}
		}
//		final Object insertNewLineAfterOpeningBraceInArrayInitializerOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER);
//		if (insertNewLineAfterOpeningBraceInArrayInitializerOption != null) {
//			this.insert_new_line_after_opening_brace_in_array_initializer = CCorePlugin.INSERT.equals(insertNewLineAfterOpeningBraceInArrayInitializerOption);
//		}
//		final Object insertNewLineAtEndOfFileIfMissingOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_AT_END_OF_FILE_IF_MISSING);
//		if (insertNewLineAtEndOfFileIfMissingOption != null) {
//			this.insert_new_line_at_end_of_file_if_missing = CCorePlugin.INSERT.equals(insertNewLineAtEndOfFileIfMissingOption);
//		}
//		final Object insertNewLineBeforeCatchInTryStatementOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT);
//		if (insertNewLineBeforeCatchInTryStatementOption != null) {
//			this.insert_new_line_before_catch_in_try_statement = CCorePlugin.INSERT.equals(insertNewLineBeforeCatchInTryStatementOption);
//		}
//		final Object insertNewLineBeforeClosingBraceInArrayInitializerOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER);
//		if (insertNewLineBeforeClosingBraceInArrayInitializerOption != null) {
//			this.insert_new_line_before_closing_brace_in_array_initializer = CCorePlugin.INSERT.equals(insertNewLineBeforeClosingBraceInArrayInitializerOption);
//		}
//		final Object insertNewLineBeforeElseInIfStatementOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT);
//		if (insertNewLineBeforeElseInIfStatementOption != null) {
//			this.insert_new_line_before_else_in_if_statement = CCorePlugin.INSERT.equals(insertNewLineBeforeElseInIfStatementOption);
//		}
//		final Object insertNewLineBeforeFinallyInTryStatementOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_FINALLY_IN_TRY_STATEMENT);
//		if (insertNewLineBeforeFinallyInTryStatementOption != null) {
//			this.insert_new_line_before_finally_in_try_statement = CCorePlugin.INSERT.equals(insertNewLineBeforeFinallyInTryStatementOption);
//		}
//		final Object insertNewLineBeforeWhileInDoStatementOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_WHILE_IN_DO_STATEMENT);
//		if (insertNewLineBeforeWhileInDoStatementOption != null) {
//			this.insert_new_line_before_while_in_do_statement = CCorePlugin.INSERT.equals(insertNewLineBeforeWhileInDoStatementOption);
//		}
//		final Object insertNewLineInEmptyBlockOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK);
//		if (insertNewLineInEmptyBlockOption != null) {
//			this.insert_new_line_in_empty_block = CCorePlugin.INSERT.equals(insertNewLineInEmptyBlockOption);
//		}
//		final Object insertNewLineInEmptyEnumConstantOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_CONSTANT);
//		if (insertNewLineInEmptyEnumConstantOption != null) {
//			this.insert_new_line_in_empty_enum_constant = CCorePlugin.INSERT.equals(insertNewLineInEmptyEnumConstantOption);
//		}
//		final Object insertNewLineInEmptyEnumDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_DECLARATION);
//		if (insertNewLineInEmptyEnumDeclarationOption != null) {
//			this.insert_new_line_in_empty_enum_declaration = CCorePlugin.INSERT.equals(insertNewLineInEmptyEnumDeclarationOption);
//		}
//		final Object insertNewLineInEmptyMethodBodyOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_METHOD_BODY);
//		if (insertNewLineInEmptyMethodBodyOption != null) {
//			this.insert_new_line_in_empty_method_body = CCorePlugin.INSERT.equals(insertNewLineInEmptyMethodBodyOption);
//		}
//		final Object insertNewLineInEmptyTypeDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_TYPE_DECLARATION);
//		if (insertNewLineInEmptyTypeDeclarationOption != null) {
//			this.insert_new_line_in_empty_type_declaration = CCorePlugin.INSERT.equals(insertNewLineInEmptyTypeDeclarationOption);
//		}
//		final Object insertSpaceAfterAndInWildcardOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_AND_IN_TYPE_PARAMETER);
//		if (insertSpaceAfterAndInWildcardOption != null) {
//			this.insert_space_after_and_in_type_parameter = CCorePlugin.INSERT.equals(insertSpaceAfterAndInWildcardOption);
//		}
//		final Object insertSpaceAfterAssignmentOperatorOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_ASSIGNMENT_OPERATOR);
//		if (insertSpaceAfterAssignmentOperatorOption != null) {
//			this.insert_space_after_assignment_operator = CCorePlugin.INSERT.equals(insertSpaceAfterAssignmentOperatorOption);
//		}
//		final Object insertSpaceAfterBinaryOperatorOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_BINARY_OPERATOR);
//		if (insertSpaceAfterBinaryOperatorOption != null) {
//			this.insert_space_after_binary_operator = CCorePlugin.INSERT.equals(insertSpaceAfterBinaryOperatorOption);
//		}
//		final Object insertSpaceAfterClosingAngleBracketInTypeArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS);
//		if (insertSpaceAfterClosingAngleBracketInTypeArgumentsOption != null) {
//			this.insert_space_after_closing_angle_bracket_in_type_arguments = CCorePlugin.INSERT.equals(insertSpaceAfterClosingAngleBracketInTypeArgumentsOption);
//		}
//		final Object insertSpaceAfterClosingAngleBracketInTypeParametersOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS);
//		if (insertSpaceAfterClosingAngleBracketInTypeParametersOption != null) {
//			this.insert_space_after_closing_angle_bracket_in_type_parameters = CCorePlugin.INSERT.equals(insertSpaceAfterClosingAngleBracketInTypeParametersOption);
//		}
//		final Object insertSpaceAfterClosingParenInCastOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST);
//		if (insertSpaceAfterClosingParenInCastOption != null) {
//			this.insert_space_after_closing_paren_in_cast = CCorePlugin.INSERT.equals(insertSpaceAfterClosingParenInCastOption);
//		}
//		final Object insertSpaceAfterClosingBraceInBlockOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_CLOSING_BRACE_IN_BLOCK);
//		if (insertSpaceAfterClosingBraceInBlockOption != null) {
//			this.insert_space_after_closing_brace_in_block = CCorePlugin.INSERT.equals(insertSpaceAfterClosingBraceInBlockOption);
//		}
//		final Object insertSpaceAfterColonInAssertOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COLON_IN_ASSERT);
//		if (insertSpaceAfterColonInAssertOption != null) {
//			this.insert_space_after_colon_in_assert = CCorePlugin.INSERT.equals(insertSpaceAfterColonInAssertOption);
//		}
//		final Object insertSpaceAfterColonInCaseOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CASE);
//		if (insertSpaceAfterColonInCaseOption != null) {
//			this.insert_space_after_colon_in_case = CCorePlugin.INSERT.equals(insertSpaceAfterColonInCaseOption);
//		}
//		final Object insertSpaceAfterColonInConditionalOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CONDITIONAL);
//		if (insertSpaceAfterColonInConditionalOption != null) {
//			this.insert_space_after_colon_in_conditional = CCorePlugin.INSERT.equals(insertSpaceAfterColonInConditionalOption);
//		}
//		final Object insertSpaceAfterColonInForOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COLON_IN_FOR);
//		if (insertSpaceAfterColonInForOption != null) {
//			this.insert_space_after_colon_in_for = CCorePlugin.INSERT.equals(insertSpaceAfterColonInForOption);
//		}
//		final Object insertSpaceAfterColonInLabeledStatementOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COLON_IN_LABELED_STATEMENT);
//		if (insertSpaceAfterColonInLabeledStatementOption != null) {
//			this.insert_space_after_colon_in_labeled_statement = CCorePlugin.INSERT.equals(insertSpaceAfterColonInLabeledStatementOption);
//		}
//		final Object insertSpaceAfterCommaInAllocationExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ALLOCATION_EXPRESSION);
//		if (insertSpaceAfterCommaInAllocationExpressionOption != null) {
//			this.insert_space_after_comma_in_allocation_expression = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInAllocationExpressionOption);
//		}
//		final Object insertSpaceAfterCommaInArrayInitializerOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ARRAY_INITIALIZER);
//		if (insertSpaceAfterCommaInArrayInitializerOption != null) {
//			this.insert_space_after_comma_in_array_initializer = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInArrayInitializerOption);
//		}
//		final Object insertSpaceAfterCommaInConstructorDeclarationParametersOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS);
//		if (insertSpaceAfterCommaInConstructorDeclarationParametersOption != null) {
//			this.insert_space_after_comma_in_constructor_declaration_parameters = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInConstructorDeclarationParametersOption);
//		}
//		final Object insertSpaceAfterCommaInConstructorDeclarationThrowsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS);
//		if (insertSpaceAfterCommaInConstructorDeclarationThrowsOption != null) {
//			this.insert_space_after_comma_in_constructor_declaration_throws = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInConstructorDeclarationThrowsOption);
//		}
//		final Object insertSpaceAfterCommaInEnumConstantArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_CONSTANT_ARGUMENTS);
//		if (insertSpaceAfterCommaInEnumConstantArgumentsOption != null) {
//			this.insert_space_after_comma_in_enum_constant_arguments = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInEnumConstantArgumentsOption);
//		}
//		final Object insertSpaceAfterCommaInEnumDeclarationsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_DECLARATIONS);
//		if (insertSpaceAfterCommaInEnumDeclarationsOption != null) {
//			this.insert_space_after_comma_in_enum_declarations = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInEnumDeclarationsOption);
//		}
//		final Object insertSpaceAfterCommaInExplicitConstructorCallArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS);
//		if (insertSpaceAfterCommaInExplicitConstructorCallArgumentsOption != null) {
//			this.insert_space_after_comma_in_explicit_constructor_call_arguments = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInExplicitConstructorCallArgumentsOption);
//		}
//		final Object insertSpaceAfterCommaInForIncrementsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INCREMENTS);
//		if (insertSpaceAfterCommaInForIncrementsOption != null) {
//			this.insert_space_after_comma_in_for_increments = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInForIncrementsOption);
//		}
//		final Object insertSpaceAfterCommaInForInitsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INITS);
//		if (insertSpaceAfterCommaInForInitsOption != null) {
//			this.insert_space_after_comma_in_for_inits = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInForInitsOption);
//		}
//		final Object insertSpaceAfterCommaInMethodInvocationArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_INVOCATION_ARGUMENTS);
//		if (insertSpaceAfterCommaInMethodInvocationArgumentsOption != null) {
//			this.insert_space_after_comma_in_method_invocation_arguments = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInMethodInvocationArgumentsOption);
//		}
//		final Object insertSpaceAfterCommaInMethodDeclarationParametersOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_PARAMETERS);
//		if (insertSpaceAfterCommaInMethodDeclarationParametersOption != null) {
//			this.insert_space_after_comma_in_method_declaration_parameters = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInMethodDeclarationParametersOption);
//		}
//		final Object insertSpaceAfterCommaInMethodDeclarationThrowsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_THROWS);
//		if (insertSpaceAfterCommaInMethodDeclarationThrowsOption != null) {
//			this.insert_space_after_comma_in_method_declaration_throws = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInMethodDeclarationThrowsOption);
//		}
//		final Object insertSpaceAfterCommaInMultipleFieldDeclarationsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS);
//		if (insertSpaceAfterCommaInMultipleFieldDeclarationsOption != null) {
//			this.insert_space_after_comma_in_multiple_field_declarations = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInMultipleFieldDeclarationsOption);
//		}
//		final Object insertSpaceAfterCommaInMultipleLocalDeclarationsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS);
//		if (insertSpaceAfterCommaInMultipleLocalDeclarationsOption != null) {
//			this.insert_space_after_comma_in_multiple_local_declarations = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInMultipleLocalDeclarationsOption);
//		}
//		final Object insertSpaceAfterCommaInParameterizedTypeReferenceOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE);
//		if (insertSpaceAfterCommaInParameterizedTypeReferenceOption != null) {
//			this.insert_space_after_comma_in_parameterized_type_reference = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInParameterizedTypeReferenceOption);
//		}
//		final Object insertSpaceAfterCommaInSuperinterfacesOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_SUPERINTERFACES);
//		if (insertSpaceAfterCommaInSuperinterfacesOption != null) {
//			this.insert_space_after_comma_in_superinterfaces = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInSuperinterfacesOption);
//		}
//		final Object insertSpaceAfterCommaInTypeArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_ARGUMENTS);
//		if (insertSpaceAfterCommaInTypeArgumentsOption != null) {
//			this.insert_space_after_comma_in_type_arguments = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInTypeArgumentsOption);
//		}
//		final Object insertSpaceAfterCommaInTypeParametersOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_PARAMETERS);
//		if (insertSpaceAfterCommaInTypeParametersOption != null) {
//			this.insert_space_after_comma_in_type_parameters = CCorePlugin.INSERT.equals(insertSpaceAfterCommaInTypeParametersOption);
//		}
//		final Object insertSpaceAfterEllipsisOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_ELLIPSIS);
//		if (insertSpaceAfterEllipsisOption != null) {
//			this.insert_space_after_ellipsis = CCorePlugin.INSERT.equals(insertSpaceAfterEllipsisOption);
//		}
//		final Object insertSpaceAfterOpeningAngleBracketInParameterizedTypeReferenceOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE);
//		if (insertSpaceAfterOpeningAngleBracketInParameterizedTypeReferenceOption != null) {
//			this.insert_space_after_opening_angle_bracket_in_parameterized_type_reference = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningAngleBracketInParameterizedTypeReferenceOption);
//		}
//		final Object insertSpaceAfterOpeningAngleBracketInTypeArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS);
//		if (insertSpaceAfterOpeningAngleBracketInTypeArgumentsOption != null) {
//			this.insert_space_after_opening_angle_bracket_in_type_arguments = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningAngleBracketInTypeArgumentsOption);
//		}
//		final Object insertSpaceAfterOpeningAngleBracketInTypeParametersOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS);
//		if (insertSpaceAfterOpeningAngleBracketInTypeParametersOption != null) {
//			this.insert_space_after_opening_angle_bracket_in_type_parameters = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningAngleBracketInTypeParametersOption);
//		}
//		final Object insertSpaceAfterOpeningBracketInArrayAllocationExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION);
//		if (insertSpaceAfterOpeningBracketInArrayAllocationExpressionOption != null) {
//			this.insert_space_after_opening_bracket_in_array_allocation_expression = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningBracketInArrayAllocationExpressionOption);
//		}
//		final Object insertSpaceAfterOpeningBracketInArrayReferenceOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_REFERENCE);
//		if (insertSpaceAfterOpeningBracketInArrayReferenceOption != null) {
//			this.insert_space_after_opening_bracket_in_array_reference = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningBracketInArrayReferenceOption);
//		}
//		final Object insertSpaceAfterOpeningBraceInArrayInitializerOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER);
//		if (insertSpaceAfterOpeningBraceInArrayInitializerOption != null) {
//			this.insert_space_after_opening_brace_in_array_initializer = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningBraceInArrayInitializerOption);
//		}
//		final Object insertSpaceAfterOpeningParenInCastOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CAST);
//		if (insertSpaceAfterOpeningParenInCastOption != null) {
//			this.insert_space_after_opening_paren_in_cast = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInCastOption);
//		}
//		final Object insertSpaceAfterOpeningParenInCatchOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CATCH);
//		if (insertSpaceAfterOpeningParenInCatchOption != null) {
//			this.insert_space_after_opening_paren_in_catch = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInCatchOption);
//		}
//		final Object insertSpaceAfterOpeningParenInConstructorDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION);
//		if (insertSpaceAfterOpeningParenInConstructorDeclarationOption != null) {
//			this.insert_space_after_opening_paren_in_constructor_declaration = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInConstructorDeclarationOption);
//		}
//		final Object insertSpaceAfterOpeningParenInEnumConstantOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_ENUM_CONSTANT);
//		if (insertSpaceAfterOpeningParenInEnumConstantOption != null) {
//			this.insert_space_after_opening_paren_in_enum_constant = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInEnumConstantOption);
//		}
//		final Object insertSpaceAfterOpeningParenInForOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_FOR);
//		if (insertSpaceAfterOpeningParenInForOption != null) {
//			this.insert_space_after_opening_paren_in_for = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInForOption);
//		}
//		final Object insertSpaceAfterOpeningParenInIfOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_IF);
//		if (insertSpaceAfterOpeningParenInIfOption != null) {
//			this.insert_space_after_opening_paren_in_if = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInIfOption);
//		}
//		final Object insertSpaceAfterOpeningParenInMethodDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_DECLARATION);
//		if (insertSpaceAfterOpeningParenInMethodDeclarationOption != null) {
//			this.insert_space_after_opening_paren_in_method_declaration = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInMethodDeclarationOption);
//		}
//		final Object insertSpaceAfterOpeningParenInMethodInvocationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_INVOCATION);
//		if (insertSpaceAfterOpeningParenInMethodInvocationOption != null) {
//			this.insert_space_after_opening_paren_in_method_invocation = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInMethodInvocationOption);
//		}
//		final Object insertSpaceAfterOpeningParenInParenthesizedExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION);
//		if (insertSpaceAfterOpeningParenInParenthesizedExpressionOption != null) {
//			this.insert_space_after_opening_paren_in_parenthesized_expression = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInParenthesizedExpressionOption);
//		}
//		final Object insertSpaceAfterOpeningParenInSwitchOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SWITCH);
//		if (insertSpaceAfterOpeningParenInSwitchOption != null) {
//			this.insert_space_after_opening_paren_in_switch = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInSwitchOption);
//		}
//		final Object insertSpaceAfterOpeningParenInSynchronizedOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SYNCHRONIZED);
//		if (insertSpaceAfterOpeningParenInSynchronizedOption != null) {
//			this.insert_space_after_opening_paren_in_synchronized = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInSynchronizedOption);
//		}
//		final Object insertSpaceAfterOpeningParenInWhileOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_WHILE);
//		if (insertSpaceAfterOpeningParenInWhileOption != null) {
//			this.insert_space_after_opening_paren_in_while = CCorePlugin.INSERT.equals(insertSpaceAfterOpeningParenInWhileOption);
//		}
//		final Object insertSpaceAfterPostfixOperatorOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_POSTFIX_OPERATOR);
//		if (insertSpaceAfterPostfixOperatorOption != null) {
//			this.insert_space_after_postfix_operator = CCorePlugin.INSERT.equals(insertSpaceAfterPostfixOperatorOption);
//		}
//		final Object insertSpaceAfterPrefixOperatorOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_PREFIX_OPERATOR);
//		if (insertSpaceAfterPrefixOperatorOption != null) {
//			this.insert_space_after_prefix_operator = CCorePlugin.INSERT.equals(insertSpaceAfterPrefixOperatorOption);
//		}
//		final Object insertSpaceAfterQuestionInConditionalOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_CONDITIONAL);
//		if (insertSpaceAfterQuestionInConditionalOption != null) {
//			this.insert_space_after_question_in_conditional = CCorePlugin.INSERT.equals(insertSpaceAfterQuestionInConditionalOption);
//		}
//		final Object insertSpaceAfterQuestionInWildcardOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_WILDCARD);
//		if (insertSpaceAfterQuestionInWildcardOption != null) {
//			this.insert_space_after_question_in_wilcard = CCorePlugin.INSERT.equals(insertSpaceAfterQuestionInWildcardOption);
//		}
//		final Object insertSpaceAfterSemicolonInForOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_SEMICOLON_IN_FOR);
//		if (insertSpaceAfterSemicolonInForOption != null) {
//			this.insert_space_after_semicolon_in_for = CCorePlugin.INSERT.equals(insertSpaceAfterSemicolonInForOption);
//		}
//		final Object insertSpaceAfterUnaryOperatorOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_UNARY_OPERATOR);
//		if (insertSpaceAfterUnaryOperatorOption != null) {
//			this.insert_space_after_unary_operator = CCorePlugin.INSERT.equals(insertSpaceAfterUnaryOperatorOption);
//		}
//		final Object insertSpaceBeforeAndInWildcardOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_AND_IN_TYPE_PARAMETER);
//		if (insertSpaceBeforeAndInWildcardOption != null) {
//			this.insert_space_before_and_in_type_parameter = CCorePlugin.INSERT.equals(insertSpaceBeforeAndInWildcardOption);
//		}
//		final Object insertSpaceBeforeAssignmentOperatorOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR);
//		if (insertSpaceBeforeAssignmentOperatorOption != null) {
//			this.insert_space_before_assignment_operator = CCorePlugin.INSERT.equals(insertSpaceBeforeAssignmentOperatorOption);
//		}
//		final Object insertSpaceBeforeBinaryOperatorOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_BINARY_OPERATOR);
//		if (insertSpaceBeforeBinaryOperatorOption != null) {
//			this.insert_space_before_binary_operator = CCorePlugin.INSERT.equals(insertSpaceBeforeBinaryOperatorOption);
//		}
//		final Object insertSpaceBeforeClosingAngleBracketInParameterizedTypeReferenceOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE);
//		if (insertSpaceBeforeClosingAngleBracketInParameterizedTypeReferenceOption != null) {
//			this.insert_space_before_closing_angle_bracket_in_parameterized_type_reference = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingAngleBracketInParameterizedTypeReferenceOption);
//		}
//		final Object insertSpaceBeforeClosingAngleBracketInTypeArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS);
//		if (insertSpaceBeforeClosingAngleBracketInTypeArgumentsOption != null) {
//			this.insert_space_before_closing_angle_bracket_in_type_arguments = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingAngleBracketInTypeArgumentsOption);
//		}
//		final Object insertSpaceBeforeClosingAngleBracketInTypeParametersOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS);
//		if (insertSpaceBeforeClosingAngleBracketInTypeParametersOption != null) {
//			this.insert_space_before_closing_angle_bracket_in_type_parameters = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingAngleBracketInTypeParametersOption);
//		}
//		final Object insertSpaceBeforeClosingBraceInArrayInitializerOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER);
//		if (insertSpaceBeforeClosingBraceInArrayInitializerOption != null) {
//			this.insert_space_before_closing_brace_in_array_initializer = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingBraceInArrayInitializerOption);
//		}
//		final Object insertSpaceBeforeClosingBracketInArrayAllocationExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION);
//		if (insertSpaceBeforeClosingBracketInArrayAllocationExpressionOption != null) {
//			this.insert_space_before_closing_bracket_in_array_allocation_expression = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingBracketInArrayAllocationExpressionOption);
//		}
//		final Object insertSpaceBeforeClosingBracketInArrayReferenceOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_REFERENCE);
//		if (insertSpaceBeforeClosingBracketInArrayReferenceOption != null) {
//			this.insert_space_before_closing_bracket_in_array_reference = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingBracketInArrayReferenceOption);
//		}
//		final Object insertSpaceBeforeClosingParenInCastOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CAST);
//		if (insertSpaceBeforeClosingParenInCastOption != null) {
//			this.insert_space_before_closing_paren_in_cast = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInCastOption);
//		}
//		final Object insertSpaceBeforeClosingParenInCatchOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CATCH);
//		if (insertSpaceBeforeClosingParenInCatchOption != null) {
//			this.insert_space_before_closing_paren_in_catch = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInCatchOption);
//		}
//		final Object insertSpaceBeforeClosingParenInConstructorDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CONSTRUCTOR_DECLARATION);
//		if (insertSpaceBeforeClosingParenInConstructorDeclarationOption != null) {
//			this.insert_space_before_closing_paren_in_constructor_declaration = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInConstructorDeclarationOption);
//		}
//		final Object insertSpaceBeforeClosingParenInEnumConstantOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_ENUM_CONSTANT);
//		if (insertSpaceBeforeClosingParenInEnumConstantOption != null) {
//			this.insert_space_before_closing_paren_in_enum_constant = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInEnumConstantOption);
//		}
//		final Object insertSpaceBeforeClosingParenInForOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_FOR);
//		if (insertSpaceBeforeClosingParenInForOption != null) {
//			this.insert_space_before_closing_paren_in_for = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInForOption);
//		}
//		final Object insertSpaceBeforeClosingParenInIfOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_IF);
//		if (insertSpaceBeforeClosingParenInIfOption != null) {
//			this.insert_space_before_closing_paren_in_if = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInIfOption);
//		}
//		final Object insertSpaceBeforeClosingParenInMethodDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_DECLARATION);
//		if (insertSpaceBeforeClosingParenInMethodDeclarationOption != null) {
//			this.insert_space_before_closing_paren_in_method_declaration = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInMethodDeclarationOption);
//		}
//		final Object insertSpaceBeforeClosingParenInMethodInvocationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_INVOCATION);
//		if (insertSpaceBeforeClosingParenInMethodInvocationOption != null) {
//			this.insert_space_before_closing_paren_in_method_invocation = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInMethodInvocationOption);
//		}
//		final Object insertSpaceBeforeClosingParenInParenthesizedExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_PARENTHESIZED_EXPRESSION);
//		if (insertSpaceBeforeClosingParenInParenthesizedExpressionOption != null) {
//			this.insert_space_before_closing_paren_in_parenthesized_expression = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInParenthesizedExpressionOption);
//		}
//		final Object insertSpaceBeforeClosingParenInSwitchOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SWITCH);
//		if (insertSpaceBeforeClosingParenInSwitchOption != null) {
//			this.insert_space_before_closing_paren_in_switch = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInSwitchOption);
//		}
//		final Object insertSpaceBeforeClosingParenInSynchronizedOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SYNCHRONIZED);
//		if (insertSpaceBeforeClosingParenInSynchronizedOption != null) {
//			this.insert_space_before_closing_paren_in_synchronized = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInSynchronizedOption);
//		}
//		final Object insertSpaceBeforeClosingParenInWhileOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_WHILE);
//		if (insertSpaceBeforeClosingParenInWhileOption != null) {
//			this.insert_space_before_closing_paren_in_while = CCorePlugin.INSERT.equals(insertSpaceBeforeClosingParenInWhileOption);
//		}
//		final Object insertSpaceBeforeColonInAssertOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_ASSERT);
//		if (insertSpaceBeforeColonInAssertOption != null) {
//			this.insert_space_before_colon_in_assert = CCorePlugin.INSERT.equals(insertSpaceBeforeColonInAssertOption);
//		}
//		final Object insertSpaceBeforeColonInCaseOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CASE);
//		if (insertSpaceBeforeColonInCaseOption != null) {
//			this.insert_space_before_colon_in_case = CCorePlugin.INSERT.equals(insertSpaceBeforeColonInCaseOption);
//		}
//		final Object insertSpaceBeforeColonInConditionalOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CONDITIONAL);
//		if (insertSpaceBeforeColonInConditionalOption != null) {
//			this.insert_space_before_colon_in_conditional = CCorePlugin.INSERT.equals(insertSpaceBeforeColonInConditionalOption);
//		}
//		final Object insertSpaceBeforeColonInDefaultOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_DEFAULT);
//		if (insertSpaceBeforeColonInDefaultOption != null) {
//			this.insert_space_before_colon_in_default = CCorePlugin.INSERT.equals(insertSpaceBeforeColonInDefaultOption);
//		}
//		final Object insertSpaceBeforeColonInForOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_FOR);
//		if (insertSpaceBeforeColonInForOption != null) {
//			this.insert_space_before_colon_in_for = CCorePlugin.INSERT.equals(insertSpaceBeforeColonInForOption);
//		}
//		final Object insertSpaceBeforeColonInLabeledStatementOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_LABELED_STATEMENT);
//		if (insertSpaceBeforeColonInLabeledStatementOption != null) {
//			this.insert_space_before_colon_in_labeled_statement = CCorePlugin.INSERT.equals(insertSpaceBeforeColonInLabeledStatementOption);
//		}
//		final Object insertSpaceBeforeCommaInAllocationExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ALLOCATION_EXPRESSION);
//		if (insertSpaceBeforeCommaInAllocationExpressionOption != null) {
//			this.insert_space_before_comma_in_allocation_expression = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInAllocationExpressionOption);
//		}
//		final Object insertSpaceBeforeCommaInArrayInitializerOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ARRAY_INITIALIZER);
//		if (insertSpaceBeforeCommaInArrayInitializerOption != null) {
//			this.insert_space_before_comma_in_array_initializer = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInArrayInitializerOption);
//		}
//		final Object insertSpaceBeforeCommaInConstructorDeclarationParametersOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS);
//		if (insertSpaceBeforeCommaInConstructorDeclarationParametersOption != null) {
//			this.insert_space_before_comma_in_constructor_declaration_parameters = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInConstructorDeclarationParametersOption);
//		}
//		final Object insertSpaceBeforeCommaInConstructorDeclarationThrowsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS);
//		if (insertSpaceBeforeCommaInConstructorDeclarationThrowsOption != null) {
//			this.insert_space_before_comma_in_constructor_declaration_throws = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInConstructorDeclarationThrowsOption);
//		}
//		final Object insertSpaceBeforeCommaInEnumConstantArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_CONSTANT_ARGUMENTS);
//		if (insertSpaceBeforeCommaInEnumConstantArgumentsOption != null) {
//			this.insert_space_before_comma_in_enum_constant_arguments = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInEnumConstantArgumentsOption);
//		}
//		final Object insertSpaceBeforeCommaInEnumDeclarationsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_DECLARATIONS);
//		if (insertSpaceBeforeCommaInEnumDeclarationsOption != null) {
//			this.insert_space_before_comma_in_enum_declarations = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInEnumDeclarationsOption);
//		}
//		final Object insertSpaceBeforeCommaInExplicitConstructorCallArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS);
//		if (insertSpaceBeforeCommaInExplicitConstructorCallArgumentsOption != null) {
//			this.insert_space_before_comma_in_explicit_constructor_call_arguments = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInExplicitConstructorCallArgumentsOption);
//		}
//		final Object insertSpaceBeforeCommaInForIncrementsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INCREMENTS);
//		if (insertSpaceBeforeCommaInForIncrementsOption != null) {
//			this.insert_space_before_comma_in_for_increments = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInForIncrementsOption);
//		}
//		final Object insertSpaceBeforeCommaInForInitsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INITS);
//		if (insertSpaceBeforeCommaInForInitsOption != null) {
//			this.insert_space_before_comma_in_for_inits = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInForInitsOption);
//		}
//		final Object insertSpaceBeforeCommaInMethodInvocationArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_INVOCATION_ARGUMENTS);
//		if (insertSpaceBeforeCommaInMethodInvocationArgumentsOption != null) {
//			this.insert_space_before_comma_in_method_invocation_arguments = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInMethodInvocationArgumentsOption);
//		}
//		final Object insertSpaceBeforeCommaInMethodDeclarationParametersOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_PARAMETERS);
//		if (insertSpaceBeforeCommaInMethodDeclarationParametersOption != null) {
//			this.insert_space_before_comma_in_method_declaration_parameters = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInMethodDeclarationParametersOption);
//		}
//		final Object insertSpaceBeforeCommaInMethodDeclarationThrowsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_THROWS);
//		if (insertSpaceBeforeCommaInMethodDeclarationThrowsOption != null) {
//			this.insert_space_before_comma_in_method_declaration_throws = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInMethodDeclarationThrowsOption);
//		}
//		final Object insertSpaceBeforeCommaInMultipleFieldDeclarationsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS);
//		if (insertSpaceBeforeCommaInMultipleFieldDeclarationsOption != null) {
//			this.insert_space_before_comma_in_multiple_field_declarations = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInMultipleFieldDeclarationsOption);
//		}
//		final Object insertSpaceBeforeCommaInMultipleLocalDeclarationsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS);
//		if (insertSpaceBeforeCommaInMultipleLocalDeclarationsOption != null) {
//			this.insert_space_before_comma_in_multiple_local_declarations = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInMultipleLocalDeclarationsOption);
//		}
//		final Object insertSpaceBeforeCommaInParameterizedTypeReferenceOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE);
//		if (insertSpaceBeforeCommaInParameterizedTypeReferenceOption != null) {
//			this.insert_space_before_comma_in_parameterized_type_reference = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInParameterizedTypeReferenceOption);
//		}
//		final Object insertSpaceBeforeCommaInSuperinterfacesOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_SUPERINTERFACES);
//		if (insertSpaceBeforeCommaInSuperinterfacesOption != null) {
//			this.insert_space_before_comma_in_superinterfaces = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInSuperinterfacesOption);
//		}
//		final Object insertSpaceBeforeCommaInTypeArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_ARGUMENTS);
//		if (insertSpaceBeforeCommaInTypeArgumentsOption != null) {
//			this.insert_space_before_comma_in_type_arguments = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInTypeArgumentsOption);
//		}
//		final Object insertSpaceBeforeCommaInTypeParametersOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_PARAMETERS);
//		if (insertSpaceBeforeCommaInTypeParametersOption != null) {
//			this.insert_space_before_comma_in_type_parameters = CCorePlugin.INSERT.equals(insertSpaceBeforeCommaInTypeParametersOption);
//		}
//		final Object insertSpaceBeforeEllipsisOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_ELLIPSIS);
//		if (insertSpaceBeforeEllipsisOption != null) {
//			this.insert_space_before_ellipsis = CCorePlugin.INSERT.equals(insertSpaceBeforeEllipsisOption);
//		}
//		final Object insertSpaceBeforeOpeningAngleBrackerInParameterizedTypeReferenceOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE);
//		if (insertSpaceBeforeOpeningAngleBrackerInParameterizedTypeReferenceOption != null) {
//			this.insert_space_before_opening_angle_bracket_in_parameterized_type_reference = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningAngleBrackerInParameterizedTypeReferenceOption);
//		}
//		final Object insertSpaceBeforeOpeningAngleBrackerInTypeArgumentsOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS);
//		if (insertSpaceBeforeOpeningAngleBrackerInTypeArgumentsOption != null) {
//			this.insert_space_before_opening_angle_bracket_in_type_arguments = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningAngleBrackerInTypeArgumentsOption);
//		}
//		final Object insertSpaceBeforeOpeningAngleBrackerInTypeParametersOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS);
//		if (insertSpaceBeforeOpeningAngleBrackerInTypeParametersOption != null) {
//			this.insert_space_before_opening_angle_bracket_in_type_parameters = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningAngleBrackerInTypeParametersOption);
//		}
//		final Object insertSpaceBeforeOpeningBraceInArrayInitializerOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ARRAY_INITIALIZER);
//		if (insertSpaceBeforeOpeningBraceInArrayInitializerOption != null) {
//			this.insert_space_before_opening_brace_in_array_initializer = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningBraceInArrayInitializerOption);
//		}
//		final Object insertSpaceBeforeOpeningBraceInBlockOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_BLOCK);
//		if (insertSpaceBeforeOpeningBraceInBlockOption != null) {
//			this.insert_space_before_opening_brace_in_block = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningBraceInBlockOption);
//		}
//		final Object insertSpaceBeforeOpeningBraceInConstructorDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_CONSTRUCTOR_DECLARATION);
//		if (insertSpaceBeforeOpeningBraceInConstructorDeclarationOption != null) {
//			this.insert_space_before_opening_brace_in_constructor_declaration = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningBraceInConstructorDeclarationOption);
//		}
//		final Object insertSpaceBeforeOpeningBraceInEnumDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_DECLARATION);
//		if (insertSpaceBeforeOpeningBraceInEnumDeclarationOption != null) {
//			this.insert_space_before_opening_brace_in_enum_declaration = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningBraceInEnumDeclarationOption);
//		}
//		final Object insertSpaceBeforeOpeningBraceInEnumConstantOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_CONSTANT);
//		if (insertSpaceBeforeOpeningBraceInEnumConstantOption != null) {
//			this.insert_space_before_opening_brace_in_enum_constant = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningBraceInEnumConstantOption);
//		}
//		final Object insertSpaceBeforeOpeningBraceInMethodDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_METHOD_DECLARATION);
//		if (insertSpaceBeforeOpeningBraceInMethodDeclarationOption != null) {
//			this.insert_space_before_opening_brace_in_method_declaration = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningBraceInMethodDeclarationOption);
//		}
//		final Object insertSpaceBeforeOpeningBraceInTypeDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_TYPE_DECLARATION);
//		if (insertSpaceBeforeOpeningBraceInTypeDeclarationOption != null) {
//			this.insert_space_before_opening_brace_in_type_declaration = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningBraceInTypeDeclarationOption);
//		}
//		final Object insertSpaceBeforeOpeningBracketInArrayAllocationExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION);
//		if (insertSpaceBeforeOpeningBracketInArrayAllocationExpressionOption != null) {
//			this.insert_space_before_opening_bracket_in_array_allocation_expression = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningBracketInArrayAllocationExpressionOption);
//		}
//		final Object insertSpaceBeforeOpeningBracketInArrayReferenceOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_REFERENCE);
//		if (insertSpaceBeforeOpeningBracketInArrayReferenceOption != null) {
//			this.insert_space_before_opening_bracket_in_array_reference = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningBracketInArrayReferenceOption);
//		}
//		final Object insertSpaceBeforeOpeningBracketInArrayTypeReferenceOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_TYPE_REFERENCE);
//		if (insertSpaceBeforeOpeningBracketInArrayTypeReferenceOption != null) {
//			this.insert_space_before_opening_bracket_in_array_type_reference = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningBracketInArrayTypeReferenceOption);
//		}
//		final Object insertSpaceBeforeOpeningParenInCatchOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CATCH);
//		if (insertSpaceBeforeOpeningParenInCatchOption != null) {
//			this.insert_space_before_opening_paren_in_catch = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningParenInCatchOption);
//		}
//		final Object insertSpaceBeforeOpeningParenInConstructorDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION);
//		if (insertSpaceBeforeOpeningParenInConstructorDeclarationOption != null) {
//			this.insert_space_before_opening_paren_in_constructor_declaration = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningParenInConstructorDeclarationOption);
//		}
//		final Object insertSpaceBeforeOpeningParenInEnumConstantOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ENUM_CONSTANT);
//		if (insertSpaceBeforeOpeningParenInEnumConstantOption != null) {
//			this.insert_space_before_opening_paren_in_enum_constant = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningParenInEnumConstantOption);
//		}
//		final Object insertSpaceBeforeOpeningParenInForOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_FOR);
//		if (insertSpaceBeforeOpeningParenInForOption != null) {
//			this.insert_space_before_opening_paren_in_for = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningParenInForOption);
//		}
//		final Object insertSpaceBeforeOpeningParenInIfOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_IF);
//		if (insertSpaceBeforeOpeningParenInIfOption != null) {
//			this.insert_space_before_opening_paren_in_if = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningParenInIfOption);
//		}
//		final Object insertSpaceBeforeOpeningParenInMethodInvocationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_INVOCATION);
//		if (insertSpaceBeforeOpeningParenInMethodInvocationOption != null) {
//			this.insert_space_before_opening_paren_in_method_invocation = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningParenInMethodInvocationOption);
//		}
//		final Object insertSpaceBeforeOpeningParenInMethodDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_DECLARATION);
//		if (insertSpaceBeforeOpeningParenInMethodDeclarationOption != null) {
//			this.insert_space_before_opening_paren_in_method_declaration = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningParenInMethodDeclarationOption);
//		}
//		final Object insertSpaceBeforeOpeningParenInSwitchOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SWITCH);
//		if (insertSpaceBeforeOpeningParenInSwitchOption != null) {
//			this.insert_space_before_opening_paren_in_switch = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningParenInSwitchOption);
//		}
//		final Object insertSpaceBeforeOpeningBraceInSwitchOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_SWITCH);
//		if (insertSpaceBeforeOpeningBraceInSwitchOption != null) {
//			this.insert_space_before_opening_brace_in_switch = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningBraceInSwitchOption);
//		}
//		final Object insertSpaceBeforeOpeningParenInSynchronizedOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SYNCHRONIZED);
//		if (insertSpaceBeforeOpeningParenInSynchronizedOption != null) {
//			this.insert_space_before_opening_paren_in_synchronized = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningParenInSynchronizedOption);
//		}
//		final Object insertSpaceBeforeOpeningParenInParenthesizedExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION);
//		if (insertSpaceBeforeOpeningParenInParenthesizedExpressionOption != null) {
//			this.insert_space_before_opening_paren_in_parenthesized_expression = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningParenInParenthesizedExpressionOption);
//		}
//		final Object insertSpaceBeforeOpeningParenInWhileOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_WHILE);
//		if (insertSpaceBeforeOpeningParenInWhileOption != null) {
//			this.insert_space_before_opening_paren_in_while = CCorePlugin.INSERT.equals(insertSpaceBeforeOpeningParenInWhileOption);
//		}
//		final Object insertSpaceBeforeParenthesizedExpressionInReturnOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_PARENTHESIZED_EXPRESSION_IN_RETURN);
//		if (insertSpaceBeforeParenthesizedExpressionInReturnOption != null) {
//			this.insert_space_before_parenthesized_expression_in_return = CCorePlugin.INSERT.equals(insertSpaceBeforeParenthesizedExpressionInReturnOption);
//		}
//		final Object insertSpaceBeforePostfixOperatorOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_POSTFIX_OPERATOR);
//		if (insertSpaceBeforePostfixOperatorOption != null) {
//			this.insert_space_before_postfix_operator = CCorePlugin.INSERT.equals(insertSpaceBeforePostfixOperatorOption);
//		}
//		final Object insertSpaceBeforePrefixOperatorOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_PREFIX_OPERATOR);
//		if (insertSpaceBeforePrefixOperatorOption != null) {
//			this.insert_space_before_prefix_operator = CCorePlugin.INSERT.equals(insertSpaceBeforePrefixOperatorOption);
//		}
//		final Object insertSpaceBeforeQuestionInConditionalOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_CONDITIONAL);
//		if (insertSpaceBeforeQuestionInConditionalOption != null) {
//			this.insert_space_before_question_in_conditional = CCorePlugin.INSERT.equals(insertSpaceBeforeQuestionInConditionalOption);
//		}
//		final Object insertSpaceBeforeQuestionInWildcardOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_WILDCARD);
//		if (insertSpaceBeforeQuestionInWildcardOption != null) {
//			this.insert_space_before_question_in_wilcard = CCorePlugin.INSERT.equals(insertSpaceBeforeQuestionInWildcardOption);
//		}
//		final Object insertSpaceBeforeSemicolonOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON);
//		if (insertSpaceBeforeSemicolonOption != null) {
//			this.insert_space_before_semicolon = CCorePlugin.INSERT.equals(insertSpaceBeforeSemicolonOption);
//		}
//		final Object insertSpaceBeforeSemicolonInForOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON_IN_FOR);
//		if (insertSpaceBeforeSemicolonInForOption != null) {
//			this.insert_space_before_semicolon_in_for = CCorePlugin.INSERT.equals(insertSpaceBeforeSemicolonInForOption);
//		}
//		final Object insertSpaceBeforeUnaryOperatorOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_UNARY_OPERATOR);
//		if (insertSpaceBeforeUnaryOperatorOption != null) {
//			this.insert_space_before_unary_operator = CCorePlugin.INSERT.equals(insertSpaceBeforeUnaryOperatorOption);
//		}
//		final Object insertSpaceBetweenBracketsInArrayTypeReferenceOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_BRACKETS_IN_ARRAY_TYPE_REFERENCE);
//		if (insertSpaceBetweenBracketsInArrayTypeReferenceOption != null) {
//			this.insert_space_between_brackets_in_array_type_reference = CCorePlugin.INSERT.equals(insertSpaceBetweenBracketsInArrayTypeReferenceOption);
//		}
//		final Object insertSpaceBetweenEmptyBracesInArrayInitializerOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACES_IN_ARRAY_INITIALIZER);
//		if (insertSpaceBetweenEmptyBracesInArrayInitializerOption != null) {
//			this.insert_space_between_empty_braces_in_array_initializer = CCorePlugin.INSERT.equals(insertSpaceBetweenEmptyBracesInArrayInitializerOption);
//		}
//		final Object insertSpaceBetweenEmptyBracketsInArrayAllocationExpressionOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACKETS_IN_ARRAY_ALLOCATION_EXPRESSION);
//		if (insertSpaceBetweenEmptyBracketsInArrayAllocationExpressionOption != null) {
//			this.insert_space_between_empty_brackets_in_array_allocation_expression = CCorePlugin.INSERT.equals(insertSpaceBetweenEmptyBracketsInArrayAllocationExpressionOption);
//		}
//		final Object insertSpaceBetweenEmptyParensInConstructorDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_CONSTRUCTOR_DECLARATION);
//		if (insertSpaceBetweenEmptyParensInConstructorDeclarationOption != null) {
//			this.insert_space_between_empty_parens_in_constructor_declaration = CCorePlugin.INSERT.equals(insertSpaceBetweenEmptyParensInConstructorDeclarationOption);
//		}
//		final Object insertSpaceBetweenEmptyParensInEnumConstantOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_ENUM_CONSTANT);
//		if (insertSpaceBetweenEmptyParensInEnumConstantOption != null) {
//			this.insert_space_between_empty_parens_in_enum_constant = CCorePlugin.INSERT.equals(insertSpaceBetweenEmptyParensInEnumConstantOption);
//		}
//		final Object insertSpaceBetweenEmptyParensInMethodDeclarationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_DECLARATION);
//		if (insertSpaceBetweenEmptyParensInMethodDeclarationOption != null) {
//			this.insert_space_between_empty_parens_in_method_declaration = CCorePlugin.INSERT.equals(insertSpaceBetweenEmptyParensInMethodDeclarationOption);
//		}
//		final Object insertSpaceBetweenEmptyParensInMethodInvocationOption = settings.get(CodeFormatterConstants.FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_INVOCATION);
//		if (insertSpaceBetweenEmptyParensInMethodInvocationOption != null) {
//			this.insert_space_between_empty_parens_in_method_invocation = CCorePlugin.INSERT.equals(insertSpaceBetweenEmptyParensInMethodInvocationOption);
//		}
//		final Object compactElseIfOption = settings.get(CodeFormatterConstants.FORMATTER_COMPACT_ELSE_IF);
//		if (compactElseIfOption != null) {
//			this.compact_else_if = CodeFormatterConstants.TRUE.equals(compactElseIfOption);
//		}
//		final Object keepGuardianClauseOnOneLineOption = settings.get(CodeFormatterConstants.FORMATTER_KEEP_GUARDIAN_CLAUSE_ON_ONE_LINE);
//		if (keepGuardianClauseOnOneLineOption != null) {
//			this.keep_guardian_clause_on_one_line = CodeFormatterConstants.TRUE.equals(keepGuardianClauseOnOneLineOption);
//		}
//		final Object keepElseStatementOnSameLineOption = settings.get(CodeFormatterConstants.FORMATTER_KEEP_ELSE_STATEMENT_ON_SAME_LINE);
//		if (keepElseStatementOnSameLineOption != null) {
//			this.keep_else_statement_on_same_line = CodeFormatterConstants.TRUE.equals(keepElseStatementOnSameLineOption);
//		}
//		final Object keepEmptyArrayInitializerOnOneLineOption = settings.get(CodeFormatterConstants.FORMATTER_KEEP_EMPTY_ARRAY_INITIALIZER_ON_ONE_LINE);
//		if (keepEmptyArrayInitializerOnOneLineOption != null) {
//			this.keep_empty_array_initializer_on_one_line = CodeFormatterConstants.TRUE.equals(keepEmptyArrayInitializerOnOneLineOption);
//		}
//		final Object keepSimpleIfOnOneLineOption = settings.get(CodeFormatterConstants.FORMATTER_KEEP_SIMPLE_IF_ON_ONE_LINE);
//		if (keepSimpleIfOnOneLineOption != null) {
//			this.keep_simple_if_on_one_line = CodeFormatterConstants.TRUE.equals(keepSimpleIfOnOneLineOption);
//		}
//		final Object keepThenStatementOnSameLineOption = settings.get(CodeFormatterConstants.FORMATTER_KEEP_THEN_STATEMENT_ON_SAME_LINE);
//		if (keepThenStatementOnSameLineOption != null) {
//			this.keep_then_statement_on_same_line = CodeFormatterConstants.TRUE.equals(keepThenStatementOnSameLineOption);
//		}
//		final Object numberOfEmptyLinesToPreserveOption = settings.get(CodeFormatterConstants.FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE);
//		if (numberOfEmptyLinesToPreserveOption != null) {
//			try {
//				this.number_of_empty_lines_to_preserve = Integer.parseInt((String) numberOfEmptyLinesToPreserveOption);
//			} catch (NumberFormatException e) {
//				this.number_of_empty_lines_to_preserve = 0;
//			} catch(ClassCastException e) {
//				this.number_of_empty_lines_to_preserve = 0;
//			}
//		}
//		final Object putEmptyStatementOnNewLineOption = settings.get(CodeFormatterConstants.FORMATTER_PUT_EMPTY_STATEMENT_ON_NEW_LINE);
//		if (putEmptyStatementOnNewLineOption != null) {
//			this.put_empty_statement_on_new_line = CodeFormatterConstants.TRUE.equals(putEmptyStatementOnNewLineOption);
//		}
		final Object tabSizeOption = settings.get(CodeFormatterConstants.FORMATTER_TAB_SIZE);
		if (tabSizeOption != null) {
			try {
				this.tab_size = Integer.parseInt((String) tabSizeOption);
			} catch (NumberFormatException e) {
				this.tab_size = 4;
			} catch(ClassCastException e) {
				this.tab_size = 4;
			}
		}
		final Object useTabsOnlyForLeadingIndentationsOption = settings.get(CodeFormatterConstants.FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS);
		if (useTabsOnlyForLeadingIndentationsOption != null) {
			this.use_tabs_only_for_leading_indentations = CodeFormatterConstants.TRUE.equals(useTabsOnlyForLeadingIndentationsOption);
		}
		final Object pageWidthOption = settings.get(CodeFormatterConstants.FORMATTER_LINE_SPLIT);
		if (pageWidthOption != null) {
			try {
				this.page_width = Integer.parseInt((String) pageWidthOption);
			} catch (NumberFormatException e) {
				this.page_width = 80;
			} catch(ClassCastException e) {
				this.page_width = 80;
			}
		}
		final Object useTabOption = settings.get(CodeFormatterConstants.FORMATTER_TAB_CHAR);
		if (useTabOption != null) {
			if (CCorePlugin.TAB.equals(useTabOption)) {
				this.tab_char = TAB;
			} else if (CCorePlugin.SPACE.equals(useTabOption)) {
				this.tab_char = SPACE;
			} else {
				this.tab_char = MIXED;
			}
		}
	}

	public void setDefaultSettings() {
		this.alignment_for_arguments_in_allocation_expression = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_arguments_in_enum_constant = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_arguments_in_explicit_constructor_call = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_arguments_in_method_invocation = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_arguments_in_qualified_allocation_expression = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_assignment = Alignment.M_NO_ALIGNMENT;
		this.alignment_for_binary_expression = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_compact_if = Alignment.M_ONE_PER_LINE_SPLIT | Alignment.M_INDENT_BY_ONE;
		this.alignment_for_conditional_expression = Alignment.M_ONE_PER_LINE_SPLIT;
		this.alignment_for_enum_constants = Alignment.NONE;
		this.alignment_for_expressions_in_array_initializer = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_multiple_fields = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_parameters_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_parameters_in_method_declaration = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_selector_in_method_invocation = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_superclass_in_type_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
		this.alignment_for_superinterfaces_in_enum_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
		this.alignment_for_superinterfaces_in_type_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
		this.alignment_for_throws_clause_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_throws_clause_in_method_declaration = Alignment.M_COMPACT_SPLIT;
		this.align_type_members_on_columns = false;
		this.brace_position_for_array_initializer = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_block = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_block_in_case = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_constructor_declaration = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_enum_constant = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_enum_declaration = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_method_declaration = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_type_declaration = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_switch = CodeFormatterConstants.END_OF_LINE;
//		this.comment_clear_blank_lines = false;
//		this.comment_format = true;
//		this.comment_format_header = false;
//		this.comment_format_html = true;
//		this.comment_format_source = true;
//		this.comment_indent_parameter_description = true;
//		this.comment_indent_root_tags = true;
//		this.comment_insert_empty_line_before_root_tags = true;
//		this.comment_insert_new_line_for_parameter = true;
//		this.comment_line_length = 80;
		this.continuation_indentation = 2;
		this.continuation_indentation_for_array_initializer = 2;
//		this.blank_lines_after_imports = 0;
//		this.blank_lines_after_package = 0;
//		this.blank_lines_before_field = 0;
//		this.blank_lines_before_first_class_body_declaration = 0;
//		this.blank_lines_before_imports = 0;
//		this.blank_lines_before_member_type = 0;
//		this.blank_lines_before_method = 0;
//		this.blank_lines_before_new_chunk = 0;
//		this.blank_lines_before_package = 0;
//		this.blank_lines_between_type_declarations = 0;
//		this.blank_lines_at_beginning_of_method_body = 0;
		this.indent_statements_compare_to_block = true;
		this.indent_statements_compare_to_body = true;
		this.indent_body_declarations_compare_to_enum_constant_header = true;
		this.indent_body_declarations_compare_to_enum_declaration_header = true;
		this.indent_body_declarations_compare_to_type_header = true;
		this.indent_breaks_compare_to_cases = true;
		this.indent_empty_lines = false;
		this.indent_switchstatements_compare_to_cases = true;
		this.indent_switchstatements_compare_to_switch = true;
		this.indentation_size = 4;
//		this.insert_new_line_after_opening_brace_in_array_initializer = false;
//		this.insert_new_line_at_end_of_file_if_missing = false;
//		this.insert_new_line_before_catch_in_try_statement = false;
//		this.insert_new_line_before_closing_brace_in_array_initializer = false;
//		this.insert_new_line_before_else_in_if_statement = false;
//		this.insert_new_line_before_finally_in_try_statement = false;
//		this.insert_new_line_before_while_in_do_statement = false;
//		this.insert_new_line_in_empty_block = true;
//		this.insert_new_line_in_empty_enum_constant = true;
//		this.insert_new_line_in_empty_enum_declaration = true;
//		this.insert_new_line_in_empty_method_body = true;
//		this.insert_new_line_in_empty_type_declaration = true;
//		this.insert_space_after_and_in_type_parameter = true;
//		this.insert_space_after_assignment_operator = true;
//		this.insert_space_after_binary_operator = true;
//		this.insert_space_after_closing_angle_bracket_in_type_arguments = true;
//		this.insert_space_after_closing_angle_bracket_in_type_parameters = true;
//		this.insert_space_after_closing_paren_in_cast = true;
//		this.insert_space_after_closing_brace_in_block = true;
//		this.insert_space_after_colon_in_assert = true;
//		this.insert_space_after_colon_in_case = true;
//		this.insert_space_after_colon_in_conditional = true;
//		this.insert_space_after_colon_in_for = true;
//		this.insert_space_after_colon_in_labeled_statement = true;
//		this.insert_space_after_comma_in_allocation_expression = true;
//		this.insert_space_after_comma_in_array_initializer = true;
//		this.insert_space_after_comma_in_constructor_declaration_parameters = true;
//		this.insert_space_after_comma_in_constructor_declaration_throws = true;
//		this.insert_space_after_comma_in_enum_constant_arguments = true;
//		this.insert_space_after_comma_in_enum_declarations = true;
//		this.insert_space_after_comma_in_explicit_constructor_call_arguments = true;
//		this.insert_space_after_comma_in_for_increments = true;
//		this.insert_space_after_comma_in_for_inits = true;
//		this.insert_space_after_comma_in_method_invocation_arguments = true;
//		this.insert_space_after_comma_in_method_declaration_parameters = true;
//		this.insert_space_after_comma_in_method_declaration_throws = true;
//		this.insert_space_after_comma_in_multiple_field_declarations = true;
//		this.insert_space_after_comma_in_multiple_local_declarations = true;
//		this.insert_space_after_comma_in_parameterized_type_reference = true;
//		this.insert_space_after_comma_in_superinterfaces = true;
//		this.insert_space_after_comma_in_type_arguments = true;
//		this.insert_space_after_comma_in_type_parameters = true;
//		this.insert_space_after_ellipsis = true;
//		this.insert_space_after_opening_angle_bracket_in_parameterized_type_reference = false;
//		this.insert_space_after_opening_angle_bracket_in_type_arguments = false;
//		this.insert_space_after_opening_angle_bracket_in_type_parameters = false;
//		this.insert_space_after_opening_bracket_in_array_allocation_expression = false;
//		this.insert_space_after_opening_bracket_in_array_reference = false;
//		this.insert_space_after_opening_brace_in_array_initializer = false;
//		this.insert_space_after_opening_paren_in_cast = false;
//		this.insert_space_after_opening_paren_in_catch = false;
//		this.insert_space_after_opening_paren_in_constructor_declaration = false;
//		this.insert_space_after_opening_paren_in_enum_constant = false;
//		this.insert_space_after_opening_paren_in_for = false;
//		this.insert_space_after_opening_paren_in_if = false;
//		this.insert_space_after_opening_paren_in_method_declaration = false;
//		this.insert_space_after_opening_paren_in_method_invocation = false;
//		this.insert_space_after_opening_paren_in_parenthesized_expression = false;
//		this.insert_space_after_opening_paren_in_switch = false;
//		this.insert_space_after_opening_paren_in_synchronized = false;
//		this.insert_space_after_opening_paren_in_while = false;
//		this.insert_space_after_postfix_operator = false;
//		this.insert_space_after_prefix_operator = false;
//		this.insert_space_after_question_in_conditional = true;
//		this.insert_space_after_question_in_wilcard = false;
//		this.insert_space_after_semicolon_in_for = true;
//		this.insert_space_after_unary_operator = false;
//		this.insert_space_before_and_in_type_parameter = true;
//		this.insert_space_before_assignment_operator = true;
//		this.insert_space_before_binary_operator = true;
//		this.insert_space_before_closing_angle_bracket_in_parameterized_type_reference = false;
//		this.insert_space_before_closing_angle_bracket_in_type_arguments = false;
//		this.insert_space_before_closing_angle_bracket_in_type_parameters = false;
//		this.insert_space_before_closing_brace_in_array_initializer = false;
//		this.insert_space_before_closing_bracket_in_array_allocation_expression = false;
//		this.insert_space_before_closing_bracket_in_array_reference = false;
//		this.insert_space_before_closing_paren_in_cast = false;
//		this.insert_space_before_closing_paren_in_catch = false;
//		this.insert_space_before_closing_paren_in_constructor_declaration = false;
//		this.insert_space_before_closing_paren_in_enum_constant = false;
//		this.insert_space_before_closing_paren_in_for = false;
//		this.insert_space_before_closing_paren_in_if = false;
//		this.insert_space_before_closing_paren_in_method_declaration = false;
//		this.insert_space_before_closing_paren_in_method_invocation = false;
//		this.insert_space_before_closing_paren_in_parenthesized_expression = false;
//		this.insert_space_before_closing_paren_in_switch = false;
//		this.insert_space_before_closing_paren_in_synchronized = false;
//		this.insert_space_before_closing_paren_in_while = false;
//		this.insert_space_before_colon_in_assert = true;
//		this.insert_space_before_colon_in_case = true;
//		this.insert_space_before_colon_in_conditional = true;
//		this.insert_space_before_colon_in_default = true;
//		this.insert_space_before_colon_in_for = true;
//		this.insert_space_before_colon_in_labeled_statement = true;
//		this.insert_space_before_comma_in_allocation_expression = false;
//		this.insert_space_before_comma_in_array_initializer = false;
//		this.insert_space_before_comma_in_constructor_declaration_parameters = false;
//		this.insert_space_before_comma_in_constructor_declaration_throws = false;
//		this.insert_space_before_comma_in_enum_constant_arguments = false;
//		this.insert_space_before_comma_in_enum_declarations = false;
//		this.insert_space_before_comma_in_explicit_constructor_call_arguments = false;
//		this.insert_space_before_comma_in_for_increments = false;
//		this.insert_space_before_comma_in_for_inits = false;
//		this.insert_space_before_comma_in_method_invocation_arguments = false;
//		this.insert_space_before_comma_in_method_declaration_parameters = false;
//		this.insert_space_before_comma_in_method_declaration_throws = false;
//		this.insert_space_before_comma_in_multiple_field_declarations = false;
//		this.insert_space_before_comma_in_multiple_local_declarations = false;
//		this.insert_space_before_comma_in_parameterized_type_reference = false;
//		this.insert_space_before_comma_in_superinterfaces = false;
//		this.insert_space_before_comma_in_type_arguments = false;
//		this.insert_space_before_comma_in_type_parameters = false;
//		this.insert_space_before_ellipsis = false;
//		this.insert_space_before_parenthesized_expression_in_return = true;
//		this.insert_space_before_opening_angle_bracket_in_parameterized_type_reference = false;
//		this.insert_space_before_opening_angle_bracket_in_type_arguments = false;
//		this.insert_space_before_opening_angle_bracket_in_type_parameters = false;
//		this.insert_space_before_opening_brace_in_array_initializer = false;
//		this.insert_space_before_opening_brace_in_block = true;
//		this.insert_space_before_opening_brace_in_constructor_declaration = true;
//		this.insert_space_before_opening_brace_in_enum_constant = true;
//		this.insert_space_before_opening_brace_in_enum_declaration = true;
//		this.insert_space_before_opening_brace_in_method_declaration = true;
//		this.insert_space_before_opening_brace_in_switch = true;
//		this.insert_space_before_opening_brace_in_type_declaration = true;
//		this.insert_space_before_opening_bracket_in_array_allocation_expression = false;
//		this.insert_space_before_opening_bracket_in_array_reference = false;
//		this.insert_space_before_opening_bracket_in_array_type_reference = false;
//		this.insert_space_before_opening_paren_in_catch = true;
//		this.insert_space_before_opening_paren_in_constructor_declaration = false;
//		this.insert_space_before_opening_paren_in_enum_constant = false;
//		this.insert_space_before_opening_paren_in_for = true;
//		this.insert_space_before_opening_paren_in_if = true;
//		this.insert_space_before_opening_paren_in_method_invocation = false;
//		this.insert_space_before_opening_paren_in_method_declaration = false;
//		this.insert_space_before_opening_paren_in_switch = true;
//		this.insert_space_before_opening_paren_in_synchronized = true;
//		this.insert_space_before_opening_paren_in_parenthesized_expression = false;
//		this.insert_space_before_opening_paren_in_while = true;
//		this.insert_space_before_postfix_operator = false;
//		this.insert_space_before_prefix_operator = false;
//		this.insert_space_before_question_in_conditional = true;
//		this.insert_space_before_question_in_wilcard = false;
//		this.insert_space_before_semicolon = false;
//		this.insert_space_before_semicolon_in_for = false;
//		this.insert_space_before_unary_operator = false;
//		this.insert_space_between_brackets_in_array_type_reference = false;
//		this.insert_space_between_empty_braces_in_array_initializer = false;
//		this.insert_space_between_empty_brackets_in_array_allocation_expression = false;
//		this.insert_space_between_empty_parens_in_constructor_declaration = false;
//		this.insert_space_between_empty_parens_in_enum_constant = false;
//		this.insert_space_between_empty_parens_in_method_declaration = false;
//		this.insert_space_between_empty_parens_in_method_invocation = false;
//		this.compact_else_if = true;
//		this.keep_guardian_clause_on_one_line = false;
//		this.keep_else_statement_on_same_line = false;
//		this.keep_empty_array_initializer_on_one_line = false;
//		this.keep_simple_if_on_one_line = false;
//		this.keep_then_statement_on_same_line = false;
//		this.number_of_empty_lines_to_preserve = 1;
//		this.put_empty_statement_on_new_line = false;
		this.tab_size = 4;
		this.page_width = 80;
		this.tab_char = TAB; // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=49081
		this.use_tabs_only_for_leading_indentations = false;
	}
	
	public void setEclipseDefaultSettings() {
		this.alignment_for_arguments_in_allocation_expression = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_arguments_in_enum_constant = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_arguments_in_explicit_constructor_call = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_arguments_in_method_invocation = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_arguments_in_qualified_allocation_expression = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_assignment = Alignment.M_NO_ALIGNMENT;
		this.alignment_for_binary_expression = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_compact_if = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_conditional_expression = Alignment.M_NEXT_PER_LINE_SPLIT;
		this.alignment_for_enum_constants = Alignment.NONE;
		this.alignment_for_expressions_in_array_initializer = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_multiple_fields = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_parameters_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_parameters_in_method_declaration = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_selector_in_method_invocation = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_superclass_in_type_declaration = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_superinterfaces_in_enum_declaration = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_superinterfaces_in_type_declaration = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_throws_clause_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_throws_clause_in_method_declaration = Alignment.M_COMPACT_SPLIT;
		this.align_type_members_on_columns = false;
		this.brace_position_for_array_initializer = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_block = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_block_in_case = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_constructor_declaration = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_enum_constant = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_enum_declaration = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_method_declaration = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_type_declaration = CodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_switch = CodeFormatterConstants.END_OF_LINE;
//		this.comment_clear_blank_lines = false;
//		this.comment_format = true;
//		this.comment_format_header = false;
//		this.comment_format_html = true;
//		this.comment_format_source = true;
//		this.comment_indent_parameter_description = true;
//		this.comment_indent_root_tags = true;
//		this.comment_insert_empty_line_before_root_tags = true;
//		this.comment_insert_new_line_for_parameter = true;
//		this.comment_line_length = 80;
		this.continuation_indentation = 2;
		this.continuation_indentation_for_array_initializer = 2;
//		this.blank_lines_after_imports = 1;
//		this.blank_lines_after_package = 1;
//		this.blank_lines_before_field = 1;
//		this.blank_lines_before_first_class_body_declaration = 0;
//		this.blank_lines_before_imports = 1;
//		this.blank_lines_before_member_type = 1;
//		this.blank_lines_before_method = 1;
//		this.blank_lines_before_new_chunk = 1;
//		this.blank_lines_before_package = 0;
//		this.blank_lines_between_type_declarations = 1;
//		this.blank_lines_at_beginning_of_method_body = 0;
		this.indent_statements_compare_to_block = true;
		this.indent_statements_compare_to_body = true;
		this.indent_body_declarations_compare_to_enum_constant_header = true;
		this.indent_body_declarations_compare_to_enum_declaration_header = true;
		this.indent_body_declarations_compare_to_type_header = true;
		this.indent_breaks_compare_to_cases = true;
		this.indent_empty_lines = false;
		this.indent_switchstatements_compare_to_cases = true;
		this.indent_switchstatements_compare_to_switch = false;
		this.indentation_size = 4;
//		this.insert_new_line_after_opening_brace_in_array_initializer = false;
//		this.insert_new_line_at_end_of_file_if_missing = false;
//		this.insert_new_line_before_catch_in_try_statement = false;
//		this.insert_new_line_before_closing_brace_in_array_initializer = false;
//		this.insert_new_line_before_else_in_if_statement = false;
//		this.insert_new_line_before_finally_in_try_statement = false;
//		this.insert_new_line_before_while_in_do_statement = false;
//		this.insert_new_line_in_empty_block = true;
//		this.insert_new_line_in_empty_enum_constant = true;
//		this.insert_new_line_in_empty_enum_declaration = true;
//		this.insert_new_line_in_empty_method_body = true;
//		this.insert_new_line_in_empty_type_declaration = true;
//		this.insert_space_after_and_in_type_parameter = true;
//		this.insert_space_after_assignment_operator = true;
//		this.insert_space_after_binary_operator = true;
//		this.insert_space_after_closing_angle_bracket_in_type_arguments = true;
//		this.insert_space_after_closing_angle_bracket_in_type_parameters = true;
//		this.insert_space_after_closing_paren_in_cast = true;
//		this.insert_space_after_closing_brace_in_block = true;
//		this.insert_space_after_colon_in_assert = true;
//		this.insert_space_after_colon_in_case = true;
//		this.insert_space_after_colon_in_conditional = true;
//		this.insert_space_after_colon_in_for = true;
//		this.insert_space_after_colon_in_labeled_statement = true;
//		this.insert_space_after_comma_in_allocation_expression = true;
//		this.insert_space_after_comma_in_array_initializer = true;
//		this.insert_space_after_comma_in_constructor_declaration_parameters = true;
//		this.insert_space_after_comma_in_constructor_declaration_throws = true;
//		this.insert_space_after_comma_in_enum_constant_arguments = true;
//		this.insert_space_after_comma_in_enum_declarations = true;
//		this.insert_space_after_comma_in_explicit_constructor_call_arguments = true;
//		this.insert_space_after_comma_in_for_increments = true;
//		this.insert_space_after_comma_in_for_inits = true;
//		this.insert_space_after_comma_in_method_invocation_arguments = true;
//		this.insert_space_after_comma_in_method_declaration_parameters = true;
//		this.insert_space_after_comma_in_method_declaration_throws = true;
//		this.insert_space_after_comma_in_multiple_field_declarations = true;
//		this.insert_space_after_comma_in_multiple_local_declarations = true;
//		this.insert_space_after_comma_in_parameterized_type_reference = true;
//		this.insert_space_after_comma_in_superinterfaces = true;
//		this.insert_space_after_comma_in_type_arguments = true;
//		this.insert_space_after_comma_in_type_parameters = true;
//		this.insert_space_after_ellipsis = true;
//		this.insert_space_after_opening_angle_bracket_in_parameterized_type_reference = false;
//		this.insert_space_after_opening_angle_bracket_in_type_arguments = false;
//		this.insert_space_after_opening_angle_bracket_in_type_parameters = false;
//		this.insert_space_after_opening_bracket_in_array_allocation_expression = false;
//		this.insert_space_after_opening_bracket_in_array_reference = false;
//		this.insert_space_after_opening_brace_in_array_initializer = true;
//		this.insert_space_after_opening_paren_in_cast = false;
//		this.insert_space_after_opening_paren_in_catch = false;
//		this.insert_space_after_opening_paren_in_constructor_declaration = false;
//		this.insert_space_after_opening_paren_in_enum_constant = false;
//		this.insert_space_after_opening_paren_in_for = false;
//		this.insert_space_after_opening_paren_in_if = false;
//		this.insert_space_after_opening_paren_in_method_declaration = false;
//		this.insert_space_after_opening_paren_in_method_invocation = false;
//		this.insert_space_after_opening_paren_in_parenthesized_expression = false;
//		this.insert_space_after_opening_paren_in_switch = false;
//		this.insert_space_after_opening_paren_in_synchronized = false;
//		this.insert_space_after_opening_paren_in_while = false;
//		this.insert_space_after_postfix_operator = false;
//		this.insert_space_after_prefix_operator = false;
//		this.insert_space_after_question_in_conditional = true;
//		this.insert_space_after_question_in_wilcard = false;
//		this.insert_space_after_semicolon_in_for = true;
//		this.insert_space_after_unary_operator = false;
//		this.insert_space_before_and_in_type_parameter = true;
//		this.insert_space_before_assignment_operator = true;
//		this.insert_space_before_binary_operator = true;
//		this.insert_space_before_closing_angle_bracket_in_parameterized_type_reference = false;
//		this.insert_space_before_closing_angle_bracket_in_type_arguments = false;
//		this.insert_space_before_closing_angle_bracket_in_type_parameters = false;
//		this.insert_space_before_closing_brace_in_array_initializer = true;
//		this.insert_space_before_closing_bracket_in_array_allocation_expression = false;
//		this.insert_space_before_closing_bracket_in_array_reference = false;
//		this.insert_space_before_closing_paren_in_cast = false;
//		this.insert_space_before_closing_paren_in_catch = false;
//		this.insert_space_before_closing_paren_in_constructor_declaration = false;
//		this.insert_space_before_closing_paren_in_enum_constant = false;
//		this.insert_space_before_closing_paren_in_for = false;
//		this.insert_space_before_closing_paren_in_if = false;
//		this.insert_space_before_closing_paren_in_method_declaration = false;
//		this.insert_space_before_closing_paren_in_method_invocation = false;
//		this.insert_space_before_closing_paren_in_parenthesized_expression = false;
//		this.insert_space_before_closing_paren_in_switch = false;
//		this.insert_space_before_closing_paren_in_synchronized = false;
//		this.insert_space_before_closing_paren_in_while = false;
//		this.insert_space_before_colon_in_assert = true;
//		this.insert_space_before_colon_in_case = false;
//		this.insert_space_before_colon_in_conditional = true;
//		this.insert_space_before_colon_in_default = false;
//		this.insert_space_before_colon_in_for = true;
//		this.insert_space_before_colon_in_labeled_statement = false;
//		this.insert_space_before_comma_in_allocation_expression = false;
//		this.insert_space_before_comma_in_array_initializer = false;
//		this.insert_space_before_comma_in_constructor_declaration_parameters = false;
//		this.insert_space_before_comma_in_constructor_declaration_throws = false;
//		this.insert_space_before_comma_in_enum_constant_arguments = false;
//		this.insert_space_before_comma_in_enum_declarations = false;
//		this.insert_space_before_comma_in_explicit_constructor_call_arguments = false;
//		this.insert_space_before_comma_in_for_increments = false;
//		this.insert_space_before_comma_in_for_inits = false;
//		this.insert_space_before_comma_in_method_invocation_arguments = false;
//		this.insert_space_before_comma_in_method_declaration_parameters = false;
//		this.insert_space_before_comma_in_method_declaration_throws = false;
//		this.insert_space_before_comma_in_multiple_field_declarations = false;
//		this.insert_space_before_comma_in_multiple_local_declarations = false;
//		this.insert_space_before_comma_in_parameterized_type_reference = false;
//		this.insert_space_before_comma_in_superinterfaces = false;
//		this.insert_space_before_comma_in_type_arguments = false;
//		this.insert_space_before_comma_in_type_parameters = false;
//		this.insert_space_before_ellipsis = false;
//		this.insert_space_before_parenthesized_expression_in_return = true;
//		this.insert_space_before_opening_angle_bracket_in_parameterized_type_reference = false;
//		this.insert_space_before_opening_angle_bracket_in_type_arguments = false;
//		this.insert_space_before_opening_angle_bracket_in_type_parameters = false;
//		this.insert_space_before_opening_brace_in_array_initializer = true;
//		this.insert_space_before_opening_brace_in_block = true;
//		this.insert_space_before_opening_brace_in_constructor_declaration = true;
//		this.insert_space_before_opening_brace_in_enum_constant = true;
//		this.insert_space_before_opening_brace_in_enum_declaration = true;
//		this.insert_space_before_opening_brace_in_method_declaration = true;
//		this.insert_space_before_opening_brace_in_switch = true;
//		this.insert_space_before_opening_brace_in_type_declaration = true;
//		this.insert_space_before_opening_bracket_in_array_allocation_expression = false;
//		this.insert_space_before_opening_bracket_in_array_reference = false;
//		this.insert_space_before_opening_bracket_in_array_type_reference = false;
//		this.insert_space_before_opening_paren_in_catch = true;
//		this.insert_space_before_opening_paren_in_constructor_declaration = false;
//		this.insert_space_before_opening_paren_in_enum_constant = false;
//		this.insert_space_before_opening_paren_in_for = true;
//		this.insert_space_before_opening_paren_in_if = true;
//		this.insert_space_before_opening_paren_in_method_invocation = false;
//		this.insert_space_before_opening_paren_in_method_declaration = false;
//		this.insert_space_before_opening_paren_in_switch = true;
//		this.insert_space_before_opening_paren_in_synchronized = true;
//		this.insert_space_before_opening_paren_in_parenthesized_expression = false;
//		this.insert_space_before_opening_paren_in_while = true;
//		this.insert_space_before_postfix_operator = false;
//		this.insert_space_before_prefix_operator = false;
//		this.insert_space_before_question_in_conditional = true;
//		this.insert_space_before_question_in_wilcard = false;
//		this.insert_space_before_semicolon = false;
//		this.insert_space_before_semicolon_in_for = false;
//		this.insert_space_before_unary_operator = false;
//		this.insert_space_between_brackets_in_array_type_reference = false;
//		this.insert_space_between_empty_braces_in_array_initializer = false;
//		this.insert_space_between_empty_brackets_in_array_allocation_expression = false;
//		this.insert_space_between_empty_parens_in_constructor_declaration = false;
//		this.insert_space_between_empty_parens_in_enum_constant = false;
//		this.insert_space_between_empty_parens_in_method_declaration = false;
//		this.insert_space_between_empty_parens_in_method_invocation = false;
//		this.compact_else_if = true;
//		this.keep_guardian_clause_on_one_line = false;
//		this.keep_else_statement_on_same_line = false;
//		this.keep_empty_array_initializer_on_one_line = false;
//		this.keep_simple_if_on_one_line = false;
//		this.keep_then_statement_on_same_line = false;
//		this.number_of_empty_lines_to_preserve = 1;
//		this.put_empty_statement_on_new_line = true;
		this.tab_size = 4;
		this.page_width = 80;
		this.tab_char = TAB;
		this.use_tabs_only_for_leading_indentations = false;
	}
}

Return to bug 148582

Lines 161-166 Link Here

(-)src/org/eclipse/cdt/ui/PreferenceConstants.java (-1 / +50 lines)
161	public static final String EDITOR_TEXT_HOVER_MODIFIER_MASKS= "hoverModifierMasks"; //$NON-NLS-1$	161	public static final String EDITOR_TEXT_HOVER_MODIFIER_MASKS= "hoverModifierMasks"; //$NON-NLS-1$
162		162
163	/**	163	/**
		164	* A named preference that controls whether the 'close strings' feature
		165	* is enabled.
		166	* <p>
		167	* Value is of type <code>Boolean</code>.
		168	* </p>
		169	*/
		170	public final static String EDITOR_CLOSE_STRINGS= "closeStrings"; //$NON-NLS-1$
		171
		172	/**
		173	* A named preference that controls whether the 'wrap strings' feature is
		174	* enabled.
		175	* <p>
		176	* Value is of type <code>Boolean</code>.
		177	* </p>
		178	*/
		179	public final static String EDITOR_WRAP_STRINGS= "wrapStrings"; //$NON-NLS-1$
		180
		181	/**
		182	* A named preference that controls whether the 'escape strings' feature is
		183	* enabled.
		184	* <p>
		185	* Value is of type <code>Boolean</code>.
		186	* </p>
		187	*/
		188	public final static String EDITOR_ESCAPE_STRINGS= "escapeStrings"; //$NON-NLS-1$
		189
		190	/**
		191	* A named preference that controls whether the 'close brackets' feature is
		192	* enabled.
		193	* <p>
		194	* Value is of type <code>Boolean</code>.
		195	* </p>
		196	*/
		197	public final static String EDITOR_CLOSE_BRACKETS= "closeBrackets"; //$NON-NLS-1$
		198
		199	/**
		200	* A named preference that controls whether the 'close braces' feature is
		201	* enabled.
		202	* <p>
		203	* Value is of type <code>Boolean</code>.
		204	* </p>
		205	*/
		206	public final static String EDITOR_CLOSE_BRACES= "closeBraces"; //$NON-NLS-1$
		207
		208	/**
164	* The id of the best match hover contributed for extension point	209	* The id of the best match hover contributed for extension point
165	* <code>javaEditorTextHovers</code>.	210	* <code>javaEditorTextHovers</code>.
166	*	211	*
Lines 412-417 Link Here
412	store.setDefault(PreferenceConstants.EDITOR_FOLDING_METHODS, false);	457	store.setDefault(PreferenceConstants.EDITOR_FOLDING_METHODS, false);
413	store.setDefault(PreferenceConstants.EDITOR_FOLDING_MACROS, true);	458	store.setDefault(PreferenceConstants.EDITOR_FOLDING_MACROS, true);
414		459
415		460	store.setDefault(PreferenceConstants.EDITOR_CLOSE_STRINGS, true);
		461	store.setDefault(PreferenceConstants.EDITOR_CLOSE_BRACKETS, true);
		462	store.setDefault(PreferenceConstants.EDITOR_CLOSE_BRACES, true);
		463	store.setDefault(PreferenceConstants.EDITOR_WRAP_STRINGS, true);
		464	store.setDefault(PreferenceConstants.EDITOR_ESCAPE_STRINGS, false);
416	}	465	}
417	}	466	}

Lines 44-60 Link Here

(-)src/org/eclipse/cdt/internal/ui/text/CSourceViewerConfiguration.java (-5 / +31 lines)
44	import org.eclipse.jface.util.PropertyChangeEvent;	44	import org.eclipse.jface.util.PropertyChangeEvent;
45	import org.eclipse.swt.SWT;	45	import org.eclipse.swt.SWT;
46	import org.eclipse.swt.widgets.Shell;	46	import org.eclipse.swt.widgets.Shell;
		47	import org.eclipse.ui.IEditorInput;
47	import org.eclipse.ui.editors.text.TextSourceViewerConfiguration;	48	import org.eclipse.ui.editors.text.TextSourceViewerConfiguration;
48	import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;	49	import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
		50	import org.eclipse.ui.texteditor.IDocumentProvider;
49	import org.eclipse.ui.texteditor.ITextEditor;	51	import org.eclipse.ui.texteditor.ITextEditor;
50		52
51	import org.eclipse.cdt.core.dom.ast.gnu.c.GCCLanguage;	53	import org.eclipse.cdt.core.dom.ast.gnu.c.GCCLanguage;
52	import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;	54	import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;
		55	import org.eclipse.cdt.core.model.ICElement;
		56	import org.eclipse.cdt.core.model.ICProject;
53	import org.eclipse.cdt.core.model.ILanguage;	57	import org.eclipse.cdt.core.model.ILanguage;
54	import org.eclipse.cdt.ui.CElementContentProvider;	58	import org.eclipse.cdt.ui.CElementContentProvider;
55	import org.eclipse.cdt.ui.CUIPlugin;	59	import org.eclipse.cdt.ui.CUIPlugin;
56	import org.eclipse.cdt.ui.ILanguageUI;	60	import org.eclipse.cdt.ui.ILanguageUI;
57		61
		62	import org.eclipse.cdt.internal.ui.editor.CDocumentProvider;
58	import org.eclipse.cdt.internal.ui.editor.CEditor;	63	import org.eclipse.cdt.internal.ui.editor.CEditor;
59	import org.eclipse.cdt.internal.ui.editor.CElementHyperlinkDetector;	64	import org.eclipse.cdt.internal.ui.editor.CElementHyperlinkDetector;
60	import org.eclipse.cdt.internal.ui.editor.CSourceViewer;	65	import org.eclipse.cdt.internal.ui.editor.CSourceViewer;
Lines 64-70 Link Here
64	import org.eclipse.cdt.internal.ui.text.contentassist.ContentAssistPreference;	69	import org.eclipse.cdt.internal.ui.text.contentassist.ContentAssistPreference;
65		70
66		71
67
68	/**	72	/**
69	* Configuration for an <code>SourceViewer</code> which shows C code.	73	* Configuration for an <code>SourceViewer</code> which shows C code.
70	*/	74	*/
Lines 247-256 Link Here
247	* @see org.eclipse.jface.text.source.SourceViewerConfiguration#getAutoEditStrategies(org.eclipse.jface.text.source.ISourceViewer, java.lang.String)	251	* @see org.eclipse.jface.text.source.SourceViewerConfiguration#getAutoEditStrategies(org.eclipse.jface.text.source.ISourceViewer, java.lang.String)
248	*/	252	*/
249	public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {	253	public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {
250	if(ICPartitions.C_MULTILINE_COMMENT.equals(contentType)) {	254	String partitioning= getConfiguredDocumentPartitioning(sourceViewer);
251	return new IAutoEditStrategy[] {new CCommentAutoIndentStrategy()};	255	if (ICPartitions.C_MULTILINE_COMMENT.equals(contentType))
252	}	256	return new IAutoEditStrategy[] { new CCommentAutoIndentStrategy() };
253	return new IAutoEditStrategy[] {new CAutoIndentStrategy()};	257	// else if (ICPartitions.C_STRING.equals(contentType))
		258	// return new IAutoEditStrategy[] { new SmartSemicolonAutoEditStrategy(partitioning), new JavaStringAutoIndentStrategy(partitioning) };
		259	else
		260	return new IAutoEditStrategy[] { new CAutoIndentStrategy(partitioning, getProject()) };
254	}	261	}
255		262
256	/**	263	/**
Lines 303-308 Link Here
303	return (String[]) vector.toArray(new String[vector.size()]);	310	return (String[]) vector.toArray(new String[vector.size()]);
304	}	311	}
305		312
		313	private ICProject getProject() {
		314	ITextEditor editor= getEditor();
		315	if (editor == null)
		316	return null;
		317
		318	ICElement element= null;
		319	IEditorInput input= editor.getEditorInput();
		320	IDocumentProvider provider= editor.getDocumentProvider();
		321	if (provider instanceof CDocumentProvider) {
		322	CDocumentProvider cudp= (CDocumentProvider) provider;
		323	element= cudp.getWorkingCopy(input);
		324	}
		325
		326	if (element == null)
		327	return null;
		328
		329	return element.getCProject();
		330	}
		331
306	/**	332	/**
307	* @see SourceViewerConfiguration#getAnnotationHover(ISourceViewer)	333	* @see SourceViewerConfiguration#getAnnotationHover(ISourceViewer)
308	*/	334	*/

Lines 1428-1479 Link Here

(-)src/org/eclipse/cdt/internal/ui/editor/CEditor.java (-29 / +27 lines)
1428	}	1428	}
1429		1429
1430	public void customizeDocumentCommand(IDocument document, DocumentCommand command) {	1430	public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
1431	String text= command.text;	1431	String text = command.text;
1432	if (text == null)	1432	if (text == null)
1433	return;	1433	return;
1434		1434
1435	int index= text.indexOf('\t');	1435	int index = text.indexOf('\t');
1436	if (index > -1) {	1436	if (index > -1) {
1437		1437	StringBuffer buffer = new StringBuffer();
1438	StringBuffer buffer= new StringBuffer();
1439		1438
1440	fLineTracker.set(command.text);	1439	fLineTracker.set(command.text);
1441	int lines= fLineTracker.getNumberOfLines();	1440	int lines = fLineTracker.getNumberOfLines();
1442		1441
1443	try {	1442	try {
		1443	for (int i = 0; i < lines; i++) {
		1444	int offset = fLineTracker.getLineOffset(i);
		1445	int endOffset = offset + fLineTracker.getLineLength(i);
		1446	String line = text.substring(offset, endOffset);
1444		1447
1445	for (int i= 0; i < lines; i++) {	1448	int position= 0;
1446		1449	if (i == 0) {
1447	int offset= fLineTracker.getLineOffset(i);	1450	IRegion firstLine = document.getLineInformationOfOffset(command.offset);
1448	int endOffset= offset + fLineTracker.getLineLength(i);	1451	position = command.offset - firstLine.getOffset();
1449	String line= text.substring(offset, endOffset);	1452	}
1450		1453
1451	int position= 0;	1454	int length = line.length();
1452	if (i == 0) {	1455	for (int j = 0; j < length; j++) {
1453	IRegion firstLine= document.getLineInformationOfOffset(command.offset);	1456	char c = line.charAt(j);
1454	position= command.offset - firstLine.getOffset();	1457	if (c == '\t') {
1455	}	1458	int oldPosition = position;
1456		1459	position += insertTabString(buffer, position);
1457	int length= line.length();	1460	if (command.caretOffset > command.offset + oldPosition) {
1458	for (int j= 0; j < length; j++) {	1461	command.caretOffset += position - oldPosition - 1;
1459	char c= line.charAt(j);
1460	if (c == '\t') {
1461	position += insertTabString(buffer, position);
1462	} else {
1463	buffer.append(c);
1464	++ position;
1465	}	1462	}
		1463	} else {
		1464	buffer.append(c);
		1465	++position;
1466	}	1466	}
1467
1468	}	1467	}
		1468	}
1469		1469
1470	command.text= buffer.toString();	1470	command.text = buffer.toString();
1471
1472	} catch (BadLocationException x) {	1471	} catch (BadLocationException x) {
1473	}	1472	}
1474	}	1473	}
1475	}	1474	}
1476
1477	}	1475	}
1478		1476
1479	/*	1477	/*

Added Link Here

(-)src/org/eclipse/cdt/ui/text/ICPartitions.java (+47 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 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	*******************************************************************************/
11	package org.eclipse.cdt.ui.text;
12
13	/**
14	* Definition of C partitioning and its partitions.
15	*/
16	public interface ICPartitions {
17
18	/**
19	* The identifier of the C partitioning.
20	*/
21	String C_PARTITIONING= "___c_partitioning"; //$NON-NLS-1$
22
23	/**
24	* The identifier of the single-line end comment partition content type.
25	*/
26	String C_SINGLE_LINE_COMMENT= "__c_singleline_comment"; //$NON-NLS-1$
27
28	/**
29	* The identifier multi-line comment partition content type.
30	*/
31	String C_MULTI_LINE_COMMENT= "__c_multiline_comment"; //$NON-NLS-1$
32
33	// /**
34	// * The identifier of the Javadoc partition content type.
35	// */
36	// String C_DOC= "__c_javadoc"; //$NON-NLS-1$
37
38	/**
39	* The identifier of the C string partition content type.
40	*/
41	String C_STRING= "__c_string"; //$NON-NLS-1$
42
43	/**
44	* The identifier of the C character partition content type.
45	*/
46	String C_CHARACTER= "__c_character"; //$NON-NLS-1$
47	}

Added Link Here

(-)src/org/eclipse/cdt/internal/ui/text/SimpleDocument.java (+374 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 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	*******************************************************************************/
11	package org.eclipse.cdt.internal.ui.text;
12
13	import org.eclipse.jface.text.IDocument;
14	import org.eclipse.jface.text.IDocumentListener;
15	import org.eclipse.jface.text.IDocumentPartitioner;
16	import org.eclipse.jface.text.IDocumentPartitioningListener;
17	import org.eclipse.jface.text.IPositionUpdater;
18	import org.eclipse.jface.text.IRegion;
19	import org.eclipse.jface.text.ITypedRegion;
20	import org.eclipse.jface.text.Position;
21
22	/**
23	* Minimal implementation of IDocument to apply text edit onto a string.
24	*/
25	public class SimpleDocument implements IDocument {
26
27	private StringBuffer buffer;
28
29	public SimpleDocument(String source) {
30	buffer = new StringBuffer(source);
31	}
32
33	public SimpleDocument(char[] source) {
34	buffer = new StringBuffer(source.length);
35	buffer.append(source);
36	}
37
38	/* (non-Javadoc)
39	* @see org.eclipse.jface.text.IDocument#getChar(int)
40	*/
41	public char getChar(int offset) {
42	return 0;
43	}
44
45	/* (non-Javadoc)
46	* @see org.eclipse.jface.text.IDocument#getLength()
47	*/
48	public int getLength() {
49	return this.buffer.length();
50	}
51
52	/* (non-Javadoc)
53	* @see org.eclipse.jface.text.IDocument#get()
54	*/
55	public String get() {
56	return this.buffer.toString();
57	}
58
59	/* (non-Javadoc)
60	* @see org.eclipse.jface.text.IDocument#get(int, int)
61	*/
62	public String get(int offset, int length) {
63	return this.buffer.substring(offset, offset + length);
64	}
65
66	/* (non-Javadoc)
67	* @see org.eclipse.jface.text.IDocument#set(java.lang.String)
68	*/
69	public void set(String text) {
70	// defining interface method
71	}
72
73	/* (non-Javadoc)
74	* @see org.eclipse.jface.text.IDocument#replace(int, int, java.lang.String)
75	*/
76	public void replace(int offset, int length, String text) {
77
78	this.buffer.replace(offset, offset + length, text);
79	}
80
81	/* (non-Javadoc)
82	* @see org.eclipse.jface.text.IDocument#addDocumentListener(org.eclipse.jface.text.IDocumentListener)
83	*/
84	public void addDocumentListener(IDocumentListener listener) {
85	// defining interface method
86	}
87
88	/* (non-Javadoc)
89	* @see org.eclipse.jface.text.IDocument#removeDocumentListener(org.eclipse.jface.text.IDocumentListener)
90	*/
91	public void removeDocumentListener(IDocumentListener listener) {
92	// defining interface method
93	}
94
95	/* (non-Javadoc)
96	* @see org.eclipse.jface.text.IDocument#addPrenotifiedDocumentListener(org.eclipse.jface.text.IDocumentListener)
97	*/
98	public void addPrenotifiedDocumentListener(IDocumentListener documentAdapter) {
99	// defining interface method
100	}
101
102	/* (non-Javadoc)
103	* @see org.eclipse.jface.text.IDocument#removePrenotifiedDocumentListener(org.eclipse.jface.text.IDocumentListener)
104	*/
105	public void removePrenotifiedDocumentListener(IDocumentListener documentAdapter) {
106	// defining interface method
107	}
108
109	/* (non-Javadoc)
110	* @see org.eclipse.jface.text.IDocument#addPositionCategory(java.lang.String)
111	*/
112	public void addPositionCategory(String category) {
113	// defining interface method
114	}
115
116	/* (non-Javadoc)
117	* @see org.eclipse.jface.text.IDocument#removePositionCategory(java.lang.String)
118	*/
119	public void removePositionCategory(String category) {
120	// defining interface method
121	}
122
123	/* (non-Javadoc)
124	* @see org.eclipse.jface.text.IDocument#getPositionCategories()
125	*/
126	public String[] getPositionCategories() {
127	// defining interface method
128	return null;
129	}
130
131	/* (non-Javadoc)
132	* @see org.eclipse.jface.text.IDocument#containsPositionCategory(java.lang.String)
133	*/
134	public boolean containsPositionCategory(String category) {
135	// defining interface method
136	return false;
137	}
138
139	/* (non-Javadoc)
140	* @see org.eclipse.jface.text.IDocument#addPosition(org.eclipse.jface.text.Position)
141	*/
142	public void addPosition(Position position) {
143	// defining interface method
144	}
145
146	/* (non-Javadoc)
147	* @see org.eclipse.jface.text.IDocument#removePosition(org.eclipse.jface.text.Position)
148	*/
149	public void removePosition(Position position) {
150	// defining interface method
151	}
152
153	/* (non-Javadoc)
154	* @see org.eclipse.jface.text.IDocument#addPosition(java.lang.String, org.eclipse.jface.text.Position)
155	*/
156	public void addPosition(String category, Position position) {
157	// defining interface method
158	}
159
160	/* (non-Javadoc)
161	* @see org.eclipse.jface.text.IDocument#removePosition(java.lang.String, org.eclipse.jface.text.Position)
162	*/
163	public void removePosition(String category, Position position) {
164	// defining interface method
165	}
166
167	/* (non-Javadoc)
168	* @see org.eclipse.jface.text.IDocument#getPositions(java.lang.String)
169	*/
170	public Position[] getPositions(String category) {
171	// defining interface method
172	return null;
173	}
174
175	/* (non-Javadoc)
176	* @see org.eclipse.jface.text.IDocument#containsPosition(java.lang.String, int, int)
177	*/
178	public boolean containsPosition(String category, int offset, int length) {
179	// defining interface method
180	return false;
181	}
182
183	/* (non-Javadoc)
184	* @see org.eclipse.jface.text.IDocument#computeIndexInCategory(java.lang.String, int)
185	*/
186	public int computeIndexInCategory(String category, int offset) {
187	// defining interface method
188	return 0;
189	}
190
191	/* (non-Javadoc)
192	* @see org.eclipse.jface.text.IDocument#addPositionUpdater(org.eclipse.jface.text.IPositionUpdater)
193	*/
194	public void addPositionUpdater(IPositionUpdater updater) {
195	// defining interface method
196	}
197
198	/* (non-Javadoc)
199	* @see org.eclipse.jface.text.IDocument#removePositionUpdater(org.eclipse.jface.text.IPositionUpdater)
200	*/
201	public void removePositionUpdater(IPositionUpdater updater) {
202	// defining interface method
203	}
204
205	/* (non-Javadoc)
206	* @see org.eclipse.jface.text.IDocument#insertPositionUpdater(org.eclipse.jface.text.IPositionUpdater, int)
207	*/
208	public void insertPositionUpdater(IPositionUpdater updater, int index) {
209	// defining interface method
210	}
211
212	/* (non-Javadoc)
213	* @see org.eclipse.jface.text.IDocument#getPositionUpdaters()
214	*/
215	public IPositionUpdater[] getPositionUpdaters() {
216	// defining interface method
217	return null;
218	}
219
220	/* (non-Javadoc)
221	* @see org.eclipse.jface.text.IDocument#getLegalContentTypes()
222	*/
223	public String[] getLegalContentTypes() {
224	// defining interface method
225	return null;
226	}
227
228	/* (non-Javadoc)
229	* @see org.eclipse.jface.text.IDocument#getContentType(int)
230	*/
231	public String getContentType(int offset) {
232	// defining interface method
233	return null;
234	}
235
236	/* (non-Javadoc)
237	* @see org.eclipse.jface.text.IDocument#getPartition(int)
238	*/
239	public ITypedRegion getPartition(int offset) {
240	// defining interface method
241	return null;
242	}
243
244	/* (non-Javadoc)
245	* @see org.eclipse.jface.text.IDocument#computePartitioning(int, int)
246	*/
247	public ITypedRegion[] computePartitioning(int offset, int length) {
248	// defining interface method
249	return null;
250	}
251
252	/* (non-Javadoc)
253	* @see org.eclipse.jface.text.IDocument#addDocumentPartitioningListener(org.eclipse.jface.text.IDocumentPartitioningListener)
254	*/
255	public void addDocumentPartitioningListener(IDocumentPartitioningListener listener) {
256	// defining interface method
257	}
258
259	/* (non-Javadoc)
260	* @see org.eclipse.jface.text.IDocument#removeDocumentPartitioningListener(org.eclipse.jface.text.IDocumentPartitioningListener)
261	*/
262	public void removeDocumentPartitioningListener(IDocumentPartitioningListener listener) {
263	// defining interface method
264	}
265
266	/* (non-Javadoc)
267	* @see org.eclipse.jface.text.IDocument#setDocumentPartitioner(org.eclipse.jface.text.IDocumentPartitioner)
268	*/
269	public void setDocumentPartitioner(IDocumentPartitioner partitioner) {
270	// defining interface method
271	}
272
273	/* (non-Javadoc)
274	* @see org.eclipse.jface.text.IDocument#getDocumentPartitioner()
275	*/
276	public IDocumentPartitioner getDocumentPartitioner() {
277	// defining interface method
278	return null;
279	}
280
281	/* (non-Javadoc)
282	* @see org.eclipse.jface.text.IDocument#getLineLength(int)
283	*/
284	public int getLineLength(int line) {
285	// defining interface method
286	return 0;
287	}
288
289	/* (non-Javadoc)
290	* @see org.eclipse.jface.text.IDocument#getLineOfOffset(int)
291	*/
292	public int getLineOfOffset(int offset) {
293	// defining interface method
294	return 0;
295	}
296
297	/* (non-Javadoc)
298	* @see org.eclipse.jface.text.IDocument#getLineOffset(int)
299	*/
300	public int getLineOffset(int line) {
301	// defining interface method
302	return 0;
303	}
304
305	/* (non-Javadoc)
306	* @see org.eclipse.jface.text.IDocument#getLineInformation(int)
307	*/
308	public IRegion getLineInformation(int line) {
309	// defining interface method
310	return null;
311	}
312
313	/* (non-Javadoc)
314	* @see org.eclipse.jface.text.IDocument#getLineInformationOfOffset(int)
315	*/
316	public IRegion getLineInformationOfOffset(int offset) {
317	// defining interface method
318	return null;
319	}
320
321	/* (non-Javadoc)
322	* @see org.eclipse.jface.text.IDocument#getNumberOfLines()
323	*/
324	public int getNumberOfLines() {
325	// defining interface method
326	return 0;
327	}
328
329	/* (non-Javadoc)
330	* @see org.eclipse.jface.text.IDocument#getNumberOfLines(int, int)
331	*/
332	public int getNumberOfLines(int offset, int length) {
333	// defining interface method
334	return 0;
335	}
336
337	/* (non-Javadoc)
338	* @see org.eclipse.jface.text.IDocument#computeNumberOfLines(java.lang.String)
339	*/
340	public int computeNumberOfLines(String text) {
341	// defining interface method
342	return 0;
343	}
344
345	/* (non-Javadoc)
346	* @see org.eclipse.jface.text.IDocument#getLegalLineDelimiters()
347	*/
348	public String[] getLegalLineDelimiters() {
349	// defining interface method
350	return null;
351	}
352
353	/* (non-Javadoc)
354	* @see org.eclipse.jface.text.IDocument#getLineDelimiter(int)
355	*/
356	public String getLineDelimiter(int line) {
357	// defining interface method
358	return null;
359	}
360
361	/**
362	* @see org.eclipse.jface.text.IDocument#search(int, java.lang.String, boolean, boolean, boolean)
363	* @deprecated
364	*/
365	public int search(
366	int startOffset,
367	String findString,
368	boolean forwardSearch,
369	boolean caseSensitive,
370	boolean wholeWord) {
371	// defining interface method
372	return 0;
373	}
374	}

Lines 141-146 Link Here

(-)src/org/eclipse/cdt/core/CCorePlugin.java (+20 lines)
141	*/	141	*/
142	public final static String CONTENT_TYPE_ASMSOURCE = "org.eclipse.cdt.core.asmSource"; //$NON-NLS-1$	142	public final static String CONTENT_TYPE_ASMSOURCE = "org.eclipse.cdt.core.asmSource"; //$NON-NLS-1$
143		143
		144	/**
		145	* Possible configurable option value.
		146	* @see #getDefaultOptions()
		147	*/
		148	public static final String INSERT = "insert"; //$NON-NLS-1$
		149	/**
		150	* Possible configurable option value.
		151	* @see #getDefaultOptions()
		152	*/
		153	public static final String DO_NOT_INSERT = "do not insert"; //$NON-NLS-1$
		154	/**
		155	* Possible configurable option value.
		156	* @see #getDefaultOptions()
		157	*/
		158	public static final String TAB = "tab"; //$NON-NLS-1$
		159	/**
		160	* Possible configurable option value.
		161	* @see #getDefaultOptions()
		162	*/
		163	public static final String SPACE = "space"; //$NON-NLS-1$
144		164
145	public CDTLogWriter cdtLog = null;	165	public CDTLogWriter cdtLog = null;
146		166

Added Link Here

(-)src/org/eclipse/cdt/internal/formatter/align/Alignment.java (+124 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 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	*******************************************************************************/
11	package org.eclipse.cdt.internal.formatter.align;
12
13
14	/**
15	* Alignment management
16	*/
17	public class Alignment {
18
19	// name of alignment
20	public String name;
21
22	// link to enclosing alignment
23	public Alignment enclosing;
24
25	// indentation management
26	public int fragmentIndex;
27	public int fragmentCount;
28	public int[] fragmentIndentations;
29	public boolean needRedoColumnAlignment;
30
31	// chunk management
32	public int chunkStartIndex;
33	public int chunkKind;
34
35	// break management
36	public int originalIndentationLevel;
37	public int breakIndentationLevel;
38	public int shiftBreakIndentationLevel;
39	public int[] fragmentBreaks;
40	public boolean wasSplit;
41
42	/*
43	* Alignment modes
44	*/
45	public static final int M_FORCE = 1; // if bit set, then alignment will be non-optional (default is optional)
46	public static final int M_INDENT_ON_COLUMN = 2; // if bit set, broken fragments will be aligned on current location column (default is to break at current indentation level)
47	public static final int M_INDENT_BY_ONE = 4; // if bit set, broken fragments will be indented one level below current (not using continuation indentation)
48
49	// split modes can be combined either with M_FORCE or M_INDENT_ON_COLUMN
50
51	/** foobar(#fragment1, #fragment2, <ul>
52	* <li> #fragment3, #fragment4 </li>
53	* </ul>
54	*/
55	public static final int M_COMPACT_SPLIT = 16; // fill each line with all possible fragments
56
57	/** foobar(<ul>
58	* <li> #fragment1, #fragment2, </li>
59	* <li> #fragment5, #fragment4, </li>
60	* </ul>
61	*/
62	public static final int M_COMPACT_FIRST_BREAK_SPLIT = 32; // compact mode, but will first try to break before first fragment
63
64	/** foobar(<ul>
65	* <li> #fragment1, </li>
66	* <li> #fragment2, </li>
67	* <li> #fragment3 </li>
68	* <li> #fragment4, </li>
69	* </ul>
70	*/
71	public static final int M_ONE_PER_LINE_SPLIT = 32+16; // one fragment per line
72
73	/**
74	* foobar(<ul>
75	* <li> #fragment1, </li>
76	* <li> #fragment2, </li>
77	* <li> #fragment3 </li>
78	* <li> #fragment4, </li>
79	* </ul>
80	*/
81	public static final int M_NEXT_SHIFTED_SPLIT = 64; // one fragment per line, subsequent are indented further
82
83	/** foobar(#fragment1, <ul>
84	* <li> #fragment2, </li>
85	* <li> #fragment3 </li>
86	* <li> #fragment4, </li>
87	* </ul>
88	*/
89	public static final int M_NEXT_PER_LINE_SPLIT = 64+16; // one per line, except first fragment (if possible)
90
91	//64+32
92	//64+32+16
93
94	// mode controlling column alignments
95	/**
96	* <table BORDER COLS=4 WIDTH="100%" >
97	* <tr><td>#fragment1A</td> <td>#fragment2A</td> <td>#fragment3A</td> <td>#very-long-fragment4A</td></tr>
98	* <tr><td>#fragment1B</td> <td>#long-fragment2B</td> <td>#fragment3B</td> <td>#fragment4B</td></tr>
99	* <tr><td>#very-long-fragment1C</td> <td>#fragment2C</td> <td>#fragment3C</td> <td>#fragment4C</td></tr>
100	* </table>
101	*/
102	public static final int M_MULTICOLUMN = 256; // fragments are on same line, but multiple line of fragments will be aligned vertically
103
104	public static final int M_NO_ALIGNMENT = 0;
105
106	public int mode;
107
108	public static final int SPLIT_MASK = M_ONE_PER_LINE_SPLIT \| M_NEXT_SHIFTED_SPLIT \| M_COMPACT_SPLIT \| M_COMPACT_FIRST_BREAK_SPLIT \| M_NEXT_PER_LINE_SPLIT;
109
110	// alignment tie-break rules - when split is needed, will decide whether innermost/outermost alignment is to be chosen
111	public static final int R_OUTERMOST = 1;
112	public static final int R_INNERMOST = 2;
113	public int tieBreakRule;
114
115	// alignment effects on a per fragment basis
116	public static int NONE = 0;
117	public static int BREAK = 1;
118
119	// chunk kind
120	public static final int CHUNK_FIELD = 1;
121	public static final int CHUNK_METHOD = 2;
122	public static final int CHUNK_TYPE = 3;
123	public static final int CHUNK_ENUM = 4;
124	}