case SyntheticMethodBinding.SwitchTable :

						// generate a method info to define the switch table synthetic method

						addSyntheticSwitchTable(syntheticMethod);

	public void addSyntheticSwitchTable(SyntheticMethodBinding methodBinding) {

		generateMethodInfoHeader(methodBinding);

		// We know that we won't get more than 1 attribute: the code attribute 

		contents[contentsOffset++] = 0;

		contents[contentsOffset++] = 2;

		// Code attribute

		int codeAttributeOffset = contentsOffset;

		generateCodeAttributeHeader();

		codeStream.init(this);

		codeStream.generateSyntheticBodyForSwitchTable(methodBinding);

		completeCodeAttributeForSyntheticMethod(

			true,

			methodBinding,

			codeAttributeOffset,

			((SourceTypeBinding) methodBinding.declaringClass)

				.scope

				.referenceCompilationUnit()

				.compilationResult

				.lineSeparatorPositions);

		// add the synthetic attribute

		int syntheticAttributeNameIndex =

			constantPool.literalIndex(AttributeNamesConstants.SyntheticName);

		contents[contentsOffset++] = (byte) (syntheticAttributeNameIndex >> 8);

		contents[contentsOffset++] = (byte) syntheticAttributeNameIndex;

		// the length of a synthetic attribute is equals to 0

		contents[contentsOffset++] = 0;

		contents[contentsOffset++] = 0;

		contents[contentsOffset++] = 0;

		contents[contentsOffset++] = 0;

	}

		this.completeCodeAttributeForSyntheticMethod(

				false,

				binding,

				codeAttributeOffset,

				startLineIndexes);

	}

	/**

	 * INTERNAL USE-ONLY

	 * That method completes the creation of the code attribute by setting

	 * - the attribute_length

	 * - max_stack

	 * - max_locals

	 * - code_length

	 * - exception table

	 * - and debug attributes if necessary.

	 *

	 * @param binding org.eclipse.jdt.internal.compiler.lookup.SyntheticAccessMethodBinding

	 * @param codeAttributeOffset <CODE>int</CODE>

	 */

	public void completeCodeAttributeForSyntheticMethod(

		boolean hasExceptionHandlers,

		SyntheticMethodBinding binding,

		int codeAttributeOffset,

		int[] startLineIndexes) {

import java.util.HashMap;

	public HashMap synthetics; // use for switch on enums types

			final TypeBinding resolvedTypeBinding = this.expression.resolvedType;

			if (caseCount > 0 && resolvedTypeBinding.isEnum()) {

				final SourceTypeBinding sourceTypeBinding = this.scope.classScope().referenceContext.binding;

				if (this.synthetics == null) {

					this.synthetics = new HashMap(2);

				}

				this.synthetics.put(resolvedTypeBinding, sourceTypeBinding.addSyntheticMethodForSwitchEnum(resolvedTypeBinding));

			}

import org.eclipse.jdt.core.compiler.CharOperation;

import org.eclipse.jdt.internal.compiler.env.IConstants;

public void generateSyntheticBodyForSwitchTable(SyntheticMethodBinding methodBinding) {

	ClassScope scope = ((SourceTypeBinding)methodBinding.declaringClass).scope;

	initializeMaxLocals(methodBinding);

	final Label nullLabel = new Label(this);

	FieldBinding syntheticFieldBinding = methodBinding.targetReadField;

	this.getstatic(syntheticFieldBinding);

	this.dup();

	this.ifnonnull(nullLabel);

	this.pop();

	ReferenceBinding enumBinding = (ReferenceBinding) methodBinding.targetEnumType;

	char[] signature = "()".toCharArray(); //$NON-NLS-1$

	ArrayBinding arrayBinding = scope.createArrayType(enumBinding, 1);

	signature = CharOperation.concat(signature, arrayBinding.constantPoolName());

	this.invoke(OPC_invokestatic, 0, 1, enumBinding.constantPoolName(), TypeConstants.VALUES, signature);

	this.arraylength();

	this.newarray(INT_ARRAY);

	this.putstatic(syntheticFieldBinding);

	final FieldBinding[] fields = enumBinding.fields();

	if (fields != null) {

		for (int i = 0, max = fields.length; i < max; i++) {

			FieldBinding fieldBinding = fields[i];

			if ((fieldBinding.getAccessFlags() & IConstants.AccEnum) != 0) {

				final Label endLabel = new Label(this);

				final ExceptionLabel anyExceptionHandler = new ExceptionLabel(this, BaseTypes.LongBinding /* represents NoSuchFieldError*/);

				this.getstatic(syntheticFieldBinding);

				this.getstatic(fieldBinding);

				this.invokeEnumOrdinal(enumBinding.constantPoolName());

				this.generateInlinedValue(fieldBinding.id);

				this.iastore();

				anyExceptionHandler.placeEnd();

				this.goto_(endLabel);

				// Generate the body of the exception handler

				final int saveStackSize = stackDepth;

				stackDepth = 1;

				anyExceptionHandler.place();

				this.pop(); // we don't use it so we can pop it

				stackDepth = saveStackSize;

				endLabel.place();				

			}

		}

	}

	this.getstatic(syntheticFieldBinding);

	nullLabel.place();

	areturn();

}

	public static final char[] JavaLangNoSuchFieldErrorConstantPoolName = "java/lang/NoSuchFieldError".toCharArray(); //$NON-NLS-1$

/*

 * Add a synthetic field to handle the cache of the switch translation table for the corresponding enum type 

 */

public SyntheticFieldBinding addSyntheticFieldForSwitchEnum(char[] fieldName, String key) {

	if (synthetics == null)

		synthetics = new HashMap[4];

	if (synthetics[FIELD_EMUL] == null)

		synthetics[FIELD_EMUL] = new HashMap(5);

	SyntheticFieldBinding synthField = (SyntheticFieldBinding) synthetics[FIELD_EMUL].get(key); //$NON-NLS-1$

	if (synthField == null) {

		synthField = new SyntheticFieldBinding(

			fieldName,

			scope.createArrayType(BaseTypes.IntBinding,1),

			AccPrivate | AccStatic | AccSynthetic | AccFinal,

			this,

			Constant.NotAConstant,

			synthetics[FIELD_EMUL].size());

		synthetics[FIELD_EMUL].put(key, synthField);

	}

	// ensure there is not already such a field defined by the user

	boolean needRecheck;

	int index = 0;

	do {

		needRecheck = false;

		FieldBinding existingField;

		if ((existingField = this.getField(synthField.name, true /*resolve*/)) != null) {

			TypeDeclaration typeDecl = scope.referenceContext;

			for (int i = 0, max = typeDecl.fields.length; i < max; i++) {

				FieldDeclaration fieldDecl = typeDecl.fields[i];

				if (fieldDecl.binding == existingField) {

					synthField.name = CharOperation.concat(

						TypeConstants.SYNTHETIC_ENUM_VALUES,

						("_" + String.valueOf(index++)).toCharArray()); //$NON-NLS-1$

					needRecheck = true;

					break;

				}

			}

		}

	} while (needRecheck);

	return synthField;

}

/* Add a new synthetic method the enum type. Selector can either be 'values' or 'valueOf'.

 * char[] constants from TypeConstants must be used: TypeConstants.VALUES/VALUEOF

*/

public SyntheticMethodBinding addSyntheticMethodForSwitchEnum(TypeBinding enumBinding) {

	if (synthetics == null)

		synthetics = new HashMap[4];

	if (synthetics[METHOD_EMUL] == null)

		synthetics[METHOD_EMUL] = new HashMap(5);

	SyntheticMethodBinding accessMethod = null;

	char[] selector = CharOperation.concat(TypeConstants.SYNTHETIC_SWITCH_ENUM_TABLE, enumBinding.constantPoolName());

	CharOperation.replace(selector, '/', '$');

	final String key = new String(selector);

	SyntheticMethodBinding[] accessors = (SyntheticMethodBinding[]) synthetics[METHOD_EMUL].get(key);

	// first add the corresponding synthetic field

	if (accessors == null) {

		// then create the synthetic method

		final SyntheticFieldBinding fieldBinding = this.addSyntheticFieldForSwitchEnum(selector, key);

		accessMethod = new SyntheticMethodBinding(fieldBinding, this, enumBinding, selector);

		synthetics[METHOD_EMUL].put(key, accessors = new SyntheticMethodBinding[2]);

		accessors[0] = accessMethod;		

	} else {

		if ((accessMethod = accessors[0]) == null) {

			final SyntheticFieldBinding fieldBinding = this.addSyntheticFieldForSwitchEnum(selector, key);

			accessMethod = new SyntheticMethodBinding(fieldBinding, this, enumBinding, selector);

			accessors[0] = accessMethod;

		}

	}

	return accessMethod;

}

	public final static int SwitchTable = 9; // switch table method

	public SyntheticMethodBinding(FieldBinding targetField, ReferenceBinding declaringClass, TypeBinding enumBinding, char[] selector) {

		this.modifiers = AccDefault | AccStatic | AccSynthetic;

		this.tagBits |= TagBits.AnnotationResolved;

		SourceTypeBinding declaringSourceType = (SourceTypeBinding) declaringClass;

		SyntheticMethodBinding[] knownAccessMethods = declaringSourceType.syntheticMethods();

		int methodId = knownAccessMethods == null ? 0 : knownAccessMethods.length;

		this.index = methodId;

		this.selector = selector;

		this.returnType = declaringSourceType.scope.createArrayType(BaseTypes.IntBinding, 1);

		this.parameters = NoParameters;

		this.targetReadField = targetField;

		this.targetEnumType = enumBinding;

		this.kind = SwitchTable;

		this.thrownExceptions = NoExceptions;

		this.declaringClass = declaringSourceType;

		if (declaringSourceType.isStrictfp()) {

			this.modifiers |= AccStrictfp;

		}

		// check for method collision

		boolean needRename;

		do {

			check : {

				needRename = false;

				// check for collision with known methods

				MethodBinding[] methods = declaringSourceType.methods;

				for (int i = 0, length = methods.length; i < length; i++) {

					if (CharOperation.equals(this.selector, methods[i].selector) && this.areParametersEqual(methods[i])) {

						needRename = true;

						break check;

					}

				}

				// check for collision with synthetic accessors

				if (knownAccessMethods != null) {

					for (int i = 0, length = knownAccessMethods.length; i < length; i++) {

						if (knownAccessMethods[i] == null) continue;

						if (CharOperation.equals(this.selector, knownAccessMethods[i].selector) && this.areParametersEqual(methods[i])) {

							needRename = true;

							break check;

						}

					}

				}

			}

			if (needRename) { // retry with a selector postfixed by a growing methodId

				this.setSelector(CharOperation.concat(TypeConstants.SYNTHETIC_ACCESS_METHOD_PREFIX, String.valueOf(++methodId).toCharArray()));

			}

		} while (needRename);

		// We now at this point - per construction - it is for sure an enclosing instance, we are going to

		// show the target field type declaration location.

		this.sourceStart = declaringSourceType.scope.referenceContext.sourceStart; // use the target declaring class name position instead

	}

	char[] SYNTHETIC_SWITCH_ENUM_TABLE = "$SWITCH_TABLE$".toCharArray(); //$NON-NLS-1$