+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2000, 2004 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Common Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/cpl-v10.html
- *
- * Contributors:
- * IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jdt.internal.compiler.ast;
-
-import org.eclipse.jdt.internal.compiler.ASTVisitor;
-import org.eclipse.jdt.internal.compiler.impl.*;
-import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
-import org.eclipse.jdt.internal.compiler.codegen.*;
-import org.eclipse.jdt.internal.compiler.flow.*;
-import org.eclipse.jdt.internal.compiler.lookup.*;
-
-public class SwitchStatement extends Statement {
-
- public Expression expression;
- public Statement[] statements;
- public BlockScope scope;
- public int explicitDeclarations;
- public Label breakLabel;
- public CaseStatement[] cases;
- public CaseStatement defaultCase;
- public int caseCount = 0;
- public int blockStart;
-
- // for local variables table attributes
- int preSwitchInitStateIndex = -1;
- int mergedInitStateIndex = -1;
-
- public FlowInfo analyseCode(
- BlockScope currentScope,
- FlowContext flowContext,
- FlowInfo flowInfo) {
-
- try {
- flowInfo = expression.analyseCode(currentScope, flowContext, flowInfo);
- SwitchFlowContext switchContext =
- new SwitchFlowContext(flowContext, this, (breakLabel = new Label()));
-
- // analyse the block by considering specially the case/default statements (need to bind them
- // to the entry point)
- FlowInfo caseInits = FlowInfo.DEAD_END;
- // in case of statements before the first case
- preSwitchInitStateIndex =
- currentScope.methodScope().recordInitializationStates(flowInfo);
- int caseIndex = 0;
- if (statements != null) {
- boolean didAlreadyComplain = false;
- for (int i = 0, max = statements.length; i < max; i++) {
- Statement statement = statements[i];
- if ((caseIndex < caseCount) && (statement == cases[caseIndex])) { // statement is a case
- this.scope.switchCase = cases[caseIndex]; // record entering in a switch case block
- caseIndex++;
- caseInits = caseInits.mergedWith(flowInfo.copy().unconditionalInits());
- didAlreadyComplain = false; // reset complaint
- } else if (statement == defaultCase) { // statement is the default case
- this.scope.switchCase = defaultCase; // record entering in a switch case block
- caseInits = caseInits.mergedWith(flowInfo.copy().unconditionalInits());
- didAlreadyComplain = false; // reset complaint
- }
- if (!statement.complainIfUnreachable(caseInits, scope, didAlreadyComplain)) {
- caseInits = statement.analyseCode(scope, switchContext, caseInits);
- } else {
- didAlreadyComplain = true;
- }
- }
- }
-
- // if no default case, then record it may jump over the block directly to the end
- if (defaultCase == null) {
- // only retain the potential initializations
- flowInfo.addPotentialInitializationsFrom(
- caseInits.mergedWith(switchContext.initsOnBreak));
- mergedInitStateIndex =
- currentScope.methodScope().recordInitializationStates(flowInfo);
- return flowInfo;
- }
-
- // merge all branches inits
- FlowInfo mergedInfo = caseInits.mergedWith(switchContext.initsOnBreak);
- mergedInitStateIndex =
- currentScope.methodScope().recordInitializationStates(mergedInfo);
- return mergedInfo;
- } finally {
- if (this.scope != null) this.scope.switchCase = null; // no longer inside switch case block
- }
- }
-
- /**
- * Switch code generation
- *
- * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
- * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
- */
- public void generateCode(BlockScope currentScope, CodeStream codeStream) {
-
- try {
- int[] sortedIndexes = new int[caseCount];
- int[] localKeysCopy;
- if ((bits & IsReachableMASK) == 0) {
- return;
- }
- int pc = codeStream.position;
-
- // prepare the labels and constants
- breakLabel.initialize(codeStream);
- CaseLabel[] caseLabels = new CaseLabel[caseCount];
- int[] constants = new int[caseCount];
- boolean needSwitch = caseCount != 0;
- for (int i = 0; i < caseCount; i++) {
- constants[i] = cases[i].constantExpression.constant.intValue();
- cases[i].targetLabel = (caseLabels[i] = new CaseLabel(codeStream));
- }
-
- // we sort the keys to be able to generate the code for tableswitch or lookupswitch
- for (int i = 0; i < caseCount; i++) {
- sortedIndexes[i] = i;
- }
- System.arraycopy(
- constants,
- 0,
- (localKeysCopy = new int[caseCount]),
- 0,
- caseCount);
- CodeStream.sort(localKeysCopy, 0, caseCount - 1, sortedIndexes);
- CaseLabel defaultLabel = new CaseLabel(codeStream);
- if (defaultCase != null) {
- defaultCase.targetLabel = defaultLabel;
- }
- // generate expression testes
- expression.generateCode(currentScope, codeStream, needSwitch);
-
- // generate the appropriate switch table/lookup bytecode
- if (needSwitch) {
- int max = localKeysCopy[caseCount - 1];
- int min = localKeysCopy[0];
- if ((long) (caseCount * 2.5) > ((long) max - (long) min)) {
-
- // 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.environment().options.complianceLevel < ClassFileConstants.JDK1_4) {
- codeStream.lookupswitch(defaultLabel, constants, sortedIndexes, caseLabels);
-
- } else {
- codeStream.tableswitch(
- defaultLabel,
- min,
- max,
- constants,
- sortedIndexes,
- caseLabels);
- }
- } else {
- codeStream.lookupswitch(defaultLabel, constants, sortedIndexes, caseLabels);
- }
- codeStream.updateLastRecordedEndPC(codeStream.position);
- }
-
- // generate the switch block statements
- int caseIndex = 0;
- if (statements != null) {
- for (int i = 0, maxCases = statements.length; i < maxCases; i++) {
- Statement statement = statements[i];
- if ((caseIndex < caseCount) && (statement == cases[caseIndex])) { // statements[i] is a case
- this.scope.switchCase = cases[caseIndex]; // record entering in a switch case block
- if (preSwitchInitStateIndex != -1) {
- codeStream.removeNotDefinitelyAssignedVariables(
- currentScope,
- preSwitchInitStateIndex);
- }
- caseIndex++;
- } else {
- if (statement == defaultCase) { // statements[i] is a case or a default case
- this.scope.switchCase = defaultCase; // record entering in a switch case block
- if (preSwitchInitStateIndex != -1) {
- codeStream.removeNotDefinitelyAssignedVariables(
- currentScope,
- preSwitchInitStateIndex);
- }
- }
- }
- statement.generateCode(scope, codeStream);
- }
- }
- // place the trailing labels (for break and default case)
- breakLabel.place();
- if (defaultCase == null) {
- defaultLabel.place();
- }
- // May loose some local variable initializations : affecting the local variable attributes
- if (mergedInitStateIndex != -1) {
- codeStream.removeNotDefinitelyAssignedVariables(
- currentScope,
- mergedInitStateIndex);
- codeStream.addDefinitelyAssignedVariables(currentScope, mergedInitStateIndex);
- }
- if (scope != currentScope) {
- codeStream.exitUserScope(scope);
- }
- codeStream.recordPositionsFrom(pc, this.sourceStart);
- } finally {
- if (this.scope != null) this.scope.switchCase = null; // no longer inside switch case block
- }
- }
-
- public StringBuffer printStatement(int indent, StringBuffer output) {
-
- printIndent(indent, output).append("switch ("); //$NON-NLS-1$
- expression.printExpression(0, output).append(") {"); //$NON-NLS-1$
- if (statements != null) {
- for (int i = 0; i < statements.length; i++) {
- output.append('\n');
- if (statements[i] instanceof CaseStatement) {
- statements[i].printStatement(indent, output);
- } else {
- statements[i].printStatement(indent+2, output);
- }
- }
- }
- output.append("\n"); //$NON-NLS-1$
- return printIndent(indent, output).append('}');
- }
-
- public void resolve(BlockScope upperScope) {
-
- try {
- TypeBinding testType = expression.resolveType(upperScope);
- if (testType == null)
- return;
- expression.implicitWidening(testType, testType);
- if (!(expression.isConstantValueOfTypeAssignableToType(testType, IntBinding))) {
- if (!testType.isCompatibleWith(IntBinding)) {
- upperScope.problemReporter().incorrectSwitchType(expression, testType);
- return;
- }
- }
- if (statements != null) {
- scope = explicitDeclarations == 0 ? upperScope : new BlockScope(upperScope);
- int length;
- // collection of cases is too big but we will only iterate until caseCount
- cases = new CaseStatement[length = statements.length];
- int[] casesValues = new int[length];
- CaseStatement[] duplicateCaseStatements = null;
- int duplicateCaseStatementsCounter = 0;
- int counter = 0;
- for (int i = 0; i < length; i++) {
- Constant constant;
- final Statement statement = statements[i];
- if ((constant = statement.resolveCase(scope, testType, this)) != null) {
- //----check for duplicate case statement------------
- if (constant != NotAConstant) {
- int key = constant.intValue();
- for (int j = 0; j < counter; j++) {
- if (casesValues[j] == key) {
- final CaseStatement currentCaseStatement = (CaseStatement) statement;
- if (duplicateCaseStatements == null) {
- scope.problemReporter().duplicateCase(cases[j]);
- scope.problemReporter().duplicateCase(currentCaseStatement);
- duplicateCaseStatements = new CaseStatement[length];
- duplicateCaseStatements[duplicateCaseStatementsCounter++] = cases[j];
- duplicateCaseStatements[duplicateCaseStatementsCounter++] = currentCaseStatement;
- } else {
- boolean found = false;
- searchReportedDuplicate: for (int k = 2; k < duplicateCaseStatementsCounter; k++) {
- if (duplicateCaseStatements[k] == statement) {
- found = true;
- break searchReportedDuplicate;
- }
- }
- if (!found) {
- scope.problemReporter().duplicateCase(currentCaseStatement);
- duplicateCaseStatements[duplicateCaseStatementsCounter++] = currentCaseStatement;
- }
- }
- }
- }
- casesValues[counter++] = key;
- }
- }
- }
- } else {
- if ((this.bits & UndocumentedEmptyBlockMASK) != 0) {
- upperScope.problemReporter().undocumentedEmptyBlock(this.blockStart, this.sourceEnd);
- }
- }
- } finally {
- if (this.scope != null) this.scope.switchCase = null; // no longer inside switch case block
- }
- }
-
- public void traverse(
- ASTVisitor visitor,
- BlockScope blockScope) {
-
- if (visitor.visit(this, blockScope)) {
- expression.traverse(visitor, scope);
- if (statements != null) {
- int statementsLength = statements.length;
- for (int i = 0; i < statementsLength; i++)
- statements[i].traverse(visitor, scope);
- }
- }
- visitor.endVisit(this, blockScope);
- }
-
- /**
- * Dispatch the call on its last statement.
- */
- public void branchChainTo(Label 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.breakLabel.hasForwardReferences()) {
- label.appendForwardReferencesFrom(this.breakLabel);
- }
- }
-}
projects / org.ibex.tool.git / blobdiff