Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2012 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 Stephan Herrmann - Contributions for bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE bug 349326 - [1.7] new warning for missing try-with-resources bug 265744 - Enum switch should warn about missing default bug 374605 - Unreasonable warning for enum-based switch statements bug 345305 - [compiler][null] Compiler misidentifies a case of "variable can only be null" /
 
 package org.eclipse.jdt.internal.compiler.ast;
 
 
 
 public class SwitchStatement extends Statement {
 
 	public Statement[] statements;
 	public BlockScope scope;
 	public int explicitDeclarations;
 	public CaseStatement[] cases;
 	public int blockStart;
 	public int caseCount;
 	int[] constants;
 
 	// fallthrough
 	public final static int CASE = 0;
 	public final static int FALLTHROUGH = 1;
 	public final static int ESCAPING = 2;
 	
 	// for switch on strings
 	private static final char[] SecretStringVariableName = " switchDispatchString".toCharArray(); //$NON-NLS-1$
 
 
 	public SyntheticMethodBinding synthetic// use for switch on enums types
 
 	// for local variables table attributes
 	int mergedInitStateIndex = -1;
 	
 
 	public FlowInfo analyseCode(BlockScope currentScopeFlowContext flowContextFlowInfo flowInfo) {
 		try {
 			flowInfo = this..analyseCode(currentScopeflowContextflowInfo);
 					|| (this.. != null && this... == )) {
 				this..checkNPE(currentScopeflowContextflowInfo);
 			}
 			SwitchFlowContext switchContext =
 				new SwitchFlowContext(flowContextthis, (this. = new BranchLabel()), true);
 
 			// analyse the block by considering specially the case/default statements (need to bind them
 			// to the entry point)
 			FlowInfo caseInits = .;
 			// in case of statements before the first case
 			int caseIndex = 0;
 			if (this. != null) {
 				int initialComplaintLevel = (flowInfo.reachMode() & .) != 0 ? . : .;
 				int complaintLevel = initialComplaintLevel;
 				int fallThroughState = ;
 				for (int i = 0, max = this..lengthi < maxi++) {
 					Statement statement = this.[i];
 					if ((caseIndex < this.) && (statement == this.[caseIndex])) { // statement is a case
 						this.. = this.[caseIndex]; // record entering in a switch case block
 						caseIndex++;
 						if (fallThroughState == 
 								&& (statement.bits & .) == 0) { // the case is not fall-through protected by a line comment
 						}
 						caseInits = caseInits.mergedWith(flowInfo.unconditionalInits());
 						complaintLevel = initialComplaintLevel// reset complaint
 						fallThroughState = ;
 					} else if (statement == this.) { // statement is the default case
 						this.. = this.// record entering in a switch case block
 						if (fallThroughState == 
 								&& (statement.bits & .) == 0) {
						}
						caseInits = caseInits.mergedWith(flowInfo.unconditionalInits());
						complaintLevel = initialComplaintLevel// reset complaint
						fallThroughState = ;
else {
						fallThroughState = // reset below if needed
					}
					if ((complaintLevel = statement.complainIfUnreachable(caseInitsthis.complaintLeveltrue)) < .) {
						caseInits = statement.analyseCode(this.switchContextcaseInits);
						if (caseInits == .) {
							fallThroughState = ;
						}
					}
				}
			}
			final TypeBinding resolvedTypeBinding = this..;
			if (resolvedTypeBinding.isEnum()) {
				final SourceTypeBinding sourceTypeBinding = currentScope.classScope()..;
				this. = sourceTypeBinding.addSyntheticMethodForSwitchEnum(resolvedTypeBinding);
			}
			// if no default case, then record it may jump over the block directly to the end
			if (this. == null) {
				// only retain the potential initializations
				flowInfo.addPotentialInitializationsFrom(caseInits.mergedWith(switchContext.initsOnBreak));
				return flowInfo;
			}
			// merge all branches inits
			FlowInfo mergedInfo = caseInits.mergedWith(switchContext.initsOnBreak);
				currentScope.methodScope().recordInitializationStates(mergedInfo);
			return mergedInfo;
finally {
			if (this. != nullthis.. = null// no longer inside switch case block
		}
	}

Switch on String code generation This assumes that hashCode() specification for java.lang.String is API and is stable.

Parameters:
currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
See also:
"http://download.oracle.com/javase/6/docs/api/java/lang/String.html"
	public void generateCodeForStringSwitch(BlockScope currentScopeCodeStream codeStream) {
		try {
			if ((this. & ) == 0) {
				return;
			}
			int pc = codeStream.position;
			class StringSwitchCase implements Comparable {
				public StringSwitchCase(int hashCodeString stringBranchLabel label) {
					this. = hashCode;
					this. = string;
					this. = label;
				}
				public int compareTo(Object o) {
					if (this. == that.hashCode) {
						return 0;
					}
					if (this. > that.hashCode) {
						return 1;
					}
					return -1;
				}
				public String toString() {
					return "StringSwitchCase :\n" + //$NON-NLS-1$
					       "case " + this. + ":(" + this. + ")\n"//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$	       
				}
			}
			final boolean hasCases = this. != 0;
			StringSwitchCase [] stringCases = new StringSwitchCase[this.]; // may have to shrink later if multiple strings hash to same code.
			BranchLabel[] sourceCaseLabels = new BranchLabel[this.];
			CaseLabel [] hashCodeCaseLabels = new CaseLabel[this.];
			this. = new int[this.];  // hashCode() values.
			for (int i = 0, max = this.i < maxi++) {
				this.[i]. = (sourceCaseLabels[i] = new BranchLabel(codeStream));  // A branch label, not a case label.
				sourceCaseLabels[i]. |= .;
				stringCases[i] = new StringSwitchCase(this.[i].hashCode(), this.[i], sourceCaseLabels[i]);
				hashCodeCaseLabels[i] = new CaseLabel(codeStream);
				hashCodeCaseLabels[i]. |= .;
			}
			Arrays.sort(stringCases);
			int uniqHashCount = 0;
			int lastHashCode = 0; 
			for (int i = 0, length = this.i < length; ++i) {
				int hashCode = stringCases[i].;
				if (i == 0 || hashCode != lastHashCode) {
					lastHashCode = this.[uniqHashCount++] = hashCode;
				}
			}
			if (uniqHashCount != this.) { // multiple keys hashed to the same value.
				System.arraycopy(this., 0, this. = new int[uniqHashCount], 0, uniqHashCount);
				System.arraycopy(hashCodeCaseLabels, 0, hashCodeCaseLabels = new CaseLabel[uniqHashCount], 0, uniqHashCount);
			}
			int[] sortedIndexes = new int[uniqHashCount]; // hash code are sorted already anyways.
			for (int i = 0; i < uniqHashCounti++) {
				sortedIndexes[i] = i;
			}
			CaseLabel defaultCaseLabel = new CaseLabel(codeStream);
			defaultCaseLabel.tagBits |= .;
			// prepare the labels and constants
			this..initialize(codeStream);
			BranchLabel defaultBranchLabel = new BranchLabel(codeStream);
			if (hasCasesdefaultBranchLabel.tagBits |= .;
			if (this. != null) {
				this.. = defaultBranchLabel;
			}
			// generate expression
			this..generateCode(currentScopecodeStreamtrue);
			codeStream.store(this.true);  // leaves string on operand stack
			if (hasCases) {
				codeStream.lookupswitch(defaultCaseLabelthis.sortedIndexeshashCodeCaseLabels);
				for (int i = 0, j = 0, max = this.i < maxi++) {
					int hashCode = stringCases[i].;
					if (i == 0 || hashCode != lastHashCode) {
						lastHashCode = hashCode;
						if (i != 0) {
							codeStream.goto_(defaultBranchLabel);
						}
						hashCodeCaseLabels[j++].place();
					}
					codeStream.load(this.);
					codeStream.ldc(stringCases[i].);
					codeStream.invokeStringEquals();
					codeStream.ifne(stringCases[i].);
				}
				codeStream.goto_(defaultBranchLabel);
else {
				codeStream.pop();
			}
			// generate the switch block statements
			int caseIndex = 0;
			if (this. != null) {
				for (int i = 0, maxCases = this..lengthi < maxCasesi++) {
					Statement statement = this.[i];
					if ((caseIndex < this.) && (statement == this.[caseIndex])) { // statements[i] is a case
						this.. = this.[caseIndex]; // record entering in a switch case block
						if (this. != -1) {
						}
						caseIndex++;
else {
						if (statement == this.) { // statements[i] is a case or a default case
							defaultCaseLabel.place(); // branch label gets placed by generateCode below.
							this.. = this.// record entering in a switch case block
							if (this. != -1) {
							}
						}
					}
					statement.generateCode(this.codeStream);
				}
			}
			// May loose some local variable initializations : affecting the local variable attributes
			if (this. != -1) {
			}
			if (this. != currentScope) {
				codeStream.exitUserScope(this.);
			}
			// place the trailing labels (for break and default case)
			if (this. == null) {
				// we want to force an line number entry to get an end position after the switch statement
				codeStream.recordPositionsFrom(codeStream.positionthis.true);
				defaultCaseLabel.place();
				defaultBranchLabel.place();
			}
			codeStream.recordPositionsFrom(pcthis.);
catch (Throwable e) {
		}
		finally {
			if (this. != nullthis.. = null// no longer inside switch case block
		}
	}


Switch code generation

Parameters:
currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
	public void generateCode(BlockScope currentScopeCodeStream codeStream) {
			generateCodeForStringSwitch(currentScopecodeStream);
			return;
		}
		try {
			if ((this. & ) == 0) {
				return;
			}
			int pc = codeStream.position;
			// prepare the labels and constants
			this..initialize(codeStream);
			CaseLabel[] caseLabels = new CaseLabel[this.];
			for (int i = 0, max = this.i < maxi++) {
				this.[i]. = (caseLabels[i] = new CaseLabel(codeStream));
				caseLabels[i]. |= .;
			}
			CaseLabel defaultLabel = new CaseLabel(codeStream);
			final boolean hasCases = this. != 0;
			if (hasCasesdefaultLabel.tagBits |= .;
			if (this. != null) {
				this.. = defaultLabel;
			}
			final TypeBinding resolvedType = this..;
			boolean valueRequired = false;
			if (resolvedType.isEnum()) {
				// go through the translation table
				codeStream.invoke(.this.null /* default declaringClass */);
				this..generateCode(currentScopecodeStreamtrue);
				// get enum constant ordinal()
				codeStream.invokeEnumOrdinal(resolvedType.constantPoolName());
				codeStream.iaload();
				if (!hasCases) {
					// we can get rid of the generated ordinal value
					codeStream.pop();
				}
else {
				valueRequired = this.. == . || hasCases;
				// generate expression
				this..generateCode(currentScopecodeStreamvalueRequired);
			}
			// generate the appropriate switch table/lookup bytecode
			if (hasCases) {
				int[] sortedIndexes = new int[this.];
				// we sort the keys to be able to generate the code for tableswitch or lookupswitch
				for (int i = 0; i < this.i++) {
					sortedIndexes[i] = i;
				}
				int[] localKeysCopy;
				System.arraycopy(this., 0, (localKeysCopy = new int[this.]), 0, this.);
				CodeStream.sort(localKeysCopy, 0, this. - 1, sortedIndexes);
				int max = localKeysCopy[this. - 1];
				int min = localKeysCopy[0];
				if ((long) (this. * 2.5) > ((longmax - (longmin)) {
					// work-around 1.3 VM bug, if max>0x7FFF0000, must use lookup bytecode
					// see http://dev.eclipse.org/bugs/show_bug.cgi?id=21557
					if (max > 0x7FFF0000 && currentScope.compilerOptions(). < .) {
						codeStream.lookupswitch(defaultLabelthis.sortedIndexescaseLabels);
else {
						codeStream.tableswitch(
							defaultLabel,
							min,
							max,
							sortedIndexes,
							caseLabels);
					}
else {
					codeStream.lookupswitch(defaultLabelthis.sortedIndexescaseLabels);
				}
				codeStream.recordPositionsFrom(codeStream.positionthis..);
else if (valueRequired) {
				codeStream.pop();
			}
			// generate the switch block statements
			int caseIndex = 0;
			if (this. != null) {
				for (int i = 0, maxCases = this..lengthi < maxCasesi++) {
					Statement statement = this.[i];
					if ((caseIndex < this.) && (statement == this.[caseIndex])) { // statements[i] is a case
						this.. = this.[caseIndex]; // record entering in a switch case block
						if (this. != -1) {
						}
						caseIndex++;
else {
						if (statement == this.) { // statements[i] is a case or a default case
							this.. = this.// record entering in a switch case block
							if (this. != -1) {
							}
						}
					}
					statement.generateCode(this.codeStream);
				}
			}
			// May loose some local variable initializations : affecting the local variable attributes
			if (this. != -1) {
			}
			if (this. != currentScope) {
				codeStream.exitUserScope(this.);
			}
			// place the trailing labels (for break and default case)
			if (this. == null) {
				// we want to force an line number entry to get an end position after the switch statement
				codeStream.recordPositionsFrom(codeStream.positionthis.true);
				defaultLabel.place();
			}
			codeStream.recordPositionsFrom(pcthis.);
finally {
			if (this. != nullthis.. = null// no longer inside switch case block
		}
	}
	public StringBuffer printStatement(int indentStringBuffer output) {
		printIndent(indentoutput).append("switch ("); //$NON-NLS-1$
		this..printExpression(0, output).append(") {"); //$NON-NLS-1$
		if (this. != null) {
			for (int i = 0; i < this..lengthi++) {
				output.append('\n');
				if (this.[iinstanceof CaseStatement) {
					this.[i].printStatement(indentoutput);
else {
					this.[i].printStatement(indent+2, output);
				}
			}
		}
		output.append("\n"); //$NON-NLS-1$
		return printIndent(indentoutput).append('}');
	}
	public void resolve(BlockScope upperScope) {
		try {
			boolean isEnumSwitch = false;
			boolean isStringSwitch = false;
			TypeBinding expressionType = this..resolveType(upperScope);
			CompilerOptions compilerOptions = upperScope.compilerOptions();
			if (expressionType != null) {
				this..computeConversion(upperScopeexpressionTypeexpressionType);
				checkType: {
					if (!expressionType.isValidBinding()) {
						expressionType = null// fault-tolerance: ignore type mismatch from constants from hereon
						break checkType;
else if (expressionType.isBaseType()) {
							break checkType;
						if (expressionType.isCompatibleWith(.))
							break checkType;
else if (expressionType.isEnum()) {
						isEnumSwitch = true;
						if (compilerOptions.complianceLevel < .) {
							upperScope.problemReporter().incorrectSwitchType(this.expressionType); // https://bugs.eclipse.org/bugs/show_bug.cgi?id=360317
						}
						break checkType;
else if (upperScope.isBoxingCompatibleWith(expressionType.)) {
						this..computeConversion(upperScope.expressionType);
						break checkType;
else if (compilerOptions.complianceLevel >= . && expressionType.id == .) {
						isStringSwitch = true;
						break checkType;
					}
					upperScope.problemReporter().incorrectSwitchType(this.expressionType);
					expressionType = null// fault-tolerance: ignore type mismatch from constants from hereon
				}
			}
			if (isStringSwitch) {
				// the secret variable should be created before iterating over the switch's statements that could
				// create more locals. This must be done to prevent overlapping of locals
				// See https://bugs.eclipse.org/bugs/show_bug.cgi?id=356002
			}
			if (this. != null) {
				this. = new BlockScope(upperScope);
				int length;
				// collection of cases is too big but we will only iterate until caseCount
				this. = new CaseStatement[length = this..length];
				if (!isStringSwitch) {
					this. = new int[length];
else {
					this. = new String[length];
				}
				int counter = 0;
				for (int i = 0; i < lengthi++) {
					Constant constant;
					final Statement statement = this.[i];
					if ((constant = statement.resolveCase(this.expressionTypethis)) != .) {
						if (!isStringSwitch) {
							int key = constant.intValue();
							//----check for duplicate case statement------------
							for (int j = 0; j < counterj++) {
								if (this.[j] == key) {
									reportDuplicateCase((CaseStatementstatementthis.[j], length);
								}
							}
							this.[counter++] = key;
else {
							String key = constant.stringValue();
							//----check for duplicate case statement------------
							for (int j = 0; j < counterj++) {
								if (this.[j].equals(key)) {
									reportDuplicateCase((CaseStatementstatementthis.[j], length);
								}
							}
							this.[counter++] = key;			
						}
					}
				}
				if (length != counter) { // resize constants array
					if (!isStringSwitch) {
						System.arraycopy(this., 0, this. = new int[counter], 0, counter);
else {
						System.arraycopy(this., 0, this. = new String[counter], 0, counter);
					}
				}
else {
				if ((this. & ) != 0) {
				}
			}
			// check default case for all kinds of switch:
			if (this. == null) {
					if (isEnumSwitch) {
						upperScope.methodScope(). = true;
					}
else {
					upperScope.problemReporter().missingDefaultCase(thisisEnumSwitchexpressionType);
				}
			}
			// for enum switch, check if all constants are accounted for (perhaps depending on existence of a default case)
			if (isEnumSwitch && compilerOptions.complianceLevel >= .) {
				if (this. == null || compilerOptions.reportMissingEnumCaseDespiteDefault) {
					int constantCount = this. == null ? 0 : this..length// could be null if no case statement
					if (constantCount == this.
							&& this. != ((ReferenceBinding)expressionType).enumConstantCount()) {
						FieldBinding[] enumFields = ((ReferenceBinding)expressionType.erasure()).fields();
						for (int i = 0, max = enumFields.lengthi <maxi++) {
							FieldBinding enumConstant = enumFields[i];
							if ((enumConstant.modifiers & .) == 0) continue;
							findConstant : {
								for (int j = 0; j < this.j++) {
									if ((enumConstant.id + 1) == this.[j]) // zero should not be returned see bug 141810
										break findConstant;
								}
								// enum constant did not get referenced from switch
								boolean suppress = (this. != null && (this.. & ) != 0);
								if (!suppress) {
									upperScope.problemReporter().missingEnumConstantCase(thisenumConstant);
								}
							}
						}
					}
				}
			}
finally {
			if (this. != nullthis.. = null// no longer inside switch case block
		}
	}
	private void reportDuplicateCase(final CaseStatement duplicatefinal CaseStatement originalint length) {
		if (this. == null) {
else {
			boolean found = false;
			searchReportedDuplicate: for (int k = 2; k < this.k++) {
				if (this.[k] == duplicate) {
					found = true;
					break searchReportedDuplicate;
				}
			}
			if (!found) {
			}
		}
	}
	public void traverse(
			ASTVisitor visitor,
			BlockScope blockScope) {
		if (visitor.visit(thisblockScope)) {
			this..traverse(visitorblockScope);
			if (this. != null) {
				int statementsLength = this..length;
				for (int i = 0; i < statementsLengthi++)
					this.[i].traverse(visitorthis.);
			}
		}
		visitor.endVisit(thisblockScope);
	}

Dispatch the call on its last statement.
	public void branchChainTo(BranchLabel label) {
		// in order to improve debug attributes for stepping (11431)
		// we want to inline the jumps to #breakLabel which already got
		// generated (if any), and have them directly branch to a better
		// location (the argument label).
		// we know at this point that the breakLabel already got placed
		if (this..forwardReferenceCount() > 0) {
		}
	}
New to GrepCode? Check out our FAQ X