Examples of org.eclipse.jdt.core.dom.SwitchCase

org.eclipse.jdt.core.dom.SwitchCase
Switch case AST node type. A switch case is a special kind of node used only in switch statements. It is a Statement in name only.
```
 SwitchCase: case Expression  : default : 
```
@since 2.0 @noinstantiate This class is not intended to be instantiated by clients.

     *
     * @param name named constant
     * @param stmt statement to be executed
     */
    public void addNamedCase(String name, StatementBuilderBase stmt) {
        SwitchCase swcase = m_ast.newSwitchCase();
        swcase.setExpression(m_ast.newSimpleName(name));
        m_switch.statements().add(swcase);
        m_switch.statements().add(stmt.getStatement());
        if (isBreakNeeded(stmt.getStatement())) {
            m_switch.statements().add(m_ast.newBreakStatement());
        }

View Full Code Here

     *
     * @param value match value
     * @param stmt statement to be executed
     */
    public void addNumberCase(String value, StatementBuilderBase stmt) {
        SwitchCase swcase = m_ast.newSwitchCase();
        swcase.setExpression(numberLiteral(value));
        m_switch.statements().add(swcase);
        m_switch.statements().add(stmt.getStatement());
        if (isBreakNeeded(stmt.getStatement())) {
            m_switch.statements().add(m_ast.newBreakStatement());
        }

View Full Code Here

     * Add default case to switch statement.
     *
     * @param stmt statement to be executed
     */
    public void addDefault(StatementBuilderBase stmt) {
        SwitchCase swcase = m_ast.newSwitchCase();
        m_switch.statements().add(swcase);
        m_switch.statements().add(stmt.getStatement());
        if (isBreakNeeded(stmt.getStatement())) {
            m_switch.statements().add(m_ast.newBreakStatement());
        }

View Full Code Here

     *
     * @param expr
     * @return block
     */
    private BlockBuilder newCaseBlock(Expression expr) {
        SwitchCase swcase = m_ast.newSwitchCase();
        swcase.setExpression(expr);
        m_switch.statements().add(swcase);
        BlockBuilder block = m_source.newBlock();
        m_switch.statements().add(block.getStatement());
        return block;
    }

View Full Code Here

      statementCFNs.add(cfn);
      if(previous != null)
        previous.addEdge(Direction.FORWARDS, cfn);
      if(astNode.getNodeType() == ASTNode.SWITCH_CASE) {
        expressionCFN.addEdge(Direction.FORWARDS, cfn);
        SwitchCase sc = (SwitchCase) astNode;
        if(sc.isDefault()) {
          if(haveSeenDefault)
            throw new CrystalRuntimeException("cannot have more than one default in a switch");
          haveSeenDefault = true;
        }
      }

View Full Code Here

            boolean isPostfix = true;


            for (int i = 0; i < operators.length; i++) {
                String operator = operators[i];


                SwitchCase switchCase = ast.newSwitchCase();
                switchCase.setExpression(ast.newNumberLiteral(Integer
                        .toString(i)));
                switchStatement.statements().add(switchCase);


                ReturnStatement returnStatement = ast.newReturnStatement();


                if (operator.equals("=")) {
                    Assignment newAssignment = (Assignment) ASTNode
                            .copySubtree(ast, assignment);
                    returnStatement.setExpression(newAssignment);
                } else if (operator.equals("++") || operator.equals("--")) {
                    Expression expression;


                    if (isPostfix) {
                        PostfixExpression postfix = ast.newPostfixExpression();
                        postfix.setOperand((Expression) ASTNode.copySubtree(
                                ast, assignment.getLeftHandSide()));
                        postfix.setOperator(PostfixExpression.Operator
                                .toOperator(operator));
                        expression = postfix;


                        // Produce prefix operators next time.
                        if (operator.equals("--")) {
                            isPostfix = false;
                        }
                    } else {
                        PrefixExpression prefix = ast.newPrefixExpression();
                        prefix.setOperand((Expression) ASTNode.copySubtree(ast,
                                assignment.getLeftHandSide()));
                        prefix.setOperator(PrefixExpression.Operator
                                .toOperator(operator));
                        expression = prefix;
                    }


                    returnStatement.setExpression(expression);
                } else {
                    Assignment newAssignment = (Assignment) ASTNode
                            .copySubtree(ast, assignment);
                    newAssignment.setOperator(Assignment.Operator
                            .toOperator(operator));
                    returnStatement.setExpression(newAssignment);
                }


                switchStatement.statements().add(returnStatement);
            }


            // The default statement: just return the old value.
            // This case should not be reached.
            SwitchCase defaultCase = ast.newSwitchCase();
            defaultCase.setExpression(null);
            switchStatement.statements().add(defaultCase);


            ReturnStatement defaultReturn = ast.newReturnStatement();
            defaultReturn.setExpression((Expression) ASTNode.copySubtree(ast,
                    assignment.getLeftHandSide()));

View Full Code Here

      final SwitchStatement sw = (SwitchStatement) node;
      this.processExpression(sw.getExpression());
      for (final Iterator it = sw.statements().iterator(); it.hasNext();) {
        final Object obj = it.next();
        if (obj instanceof SwitchCase) {
          final SwitchCase sc = (SwitchCase) obj;
          this.processExpression(sc.getExpression());
        }
      }
      break;
    }


    case ASTNode.SWITCH_CASE: {
      final SwitchCase sc = (SwitchCase) node;
      this.processExpression(sc.getExpression());
      this.process(sc.getParent());
      break;
    }


    case ASTNode.RETURN_STATEMENT: {
      final ReturnStatement rs = (ReturnStatement) node;

View Full Code Here

          indent--;
          printlni("}");
          indented = false;
        }


        SwitchCase sc = (SwitchCase) s;
        if (!sc.isDefault()) {
          cases.add(sc);
        }


        allCases.add(sc);
        wasCase = true;

View Full Code Here

    jumpsStatements.add(currentslot);


    for (Iterator<Statement> iter = node.statements().iterator(); iter.hasNext();) {
      Statement statement = iter.next();
      if (statement instanceof SwitchCase) {
        SwitchCase switchCase = (SwitchCase) statement;
        if (switchCase.isDefault()) {
          jumpDefault = new Jump();
          push(jumpDefault);
          storeInstruction(); // jump
          statementsDefault = new ArrayList<Statement>();
        } else {
          if (switchCase.getExpression() instanceof StringLiteral) {
            push(new SendMessage(
                "equals", "(Ljava/lang/Object;)Z", 1, null, fCounter)); //$NON-NLS-1$ //$NON-NLS-2$
          } else {
            push(new EqualEqualOperator(Instruction.T_int,
                Instruction.T_int, true, fCounter));
          }
          push(new Dup());
          storeInstruction(); // dupe
          switchCase.getExpression().accept(this);
          storeInstruction(); // equal-equal
          ConditionalJump condJump = new ConditionalJump(true);
          push(condJump);
          storeInstruction(); // conditional jump
          if (currentslot.stmts != null) {

View Full Code Here

    
    for(Object obj: node.statements()) {
      Statement stmt = (Statement) obj;
      if (stmt.getNodeType() == ASTNode.SWITCH_CASE) {
        CFGVertice caseVertice = graph.addNewVertice(stmt, "Switch case: " + stmt);
        SwitchCase aCase = (SwitchCase) stmt;
        if (aCase.isDefault()) {
          if (defaultTarget !=null)
            throw new MethodCFGBuilderException("Two defaults??");
          defaultTarget = caseVertice;
        } else
          cases.add(Pair.create(caseVertice, aCase.getExpression()));
        if (lastBlock !=null)
          acceptChildren(lastBlock, new ProcessingContext(previousVertice, caseVertice, context.returnDetails), true, switchBlock);
        lastBlock = new LinkedList<Statement>();
        previousVertice = caseVertice;
      } else {

View Full Code Here

TOP

Related Classes of org.eclipse.jdt.core.dom.SwitchCase

ai.cfg.MethodCFGBuilder

edu.cmu.cs.crystal.internal.ControlFlowVisitor

edu.ohio_state.khatchad.refactoring.core.ASTNodeProcessor

org.eclipse.jdt.internal.debug.eval.ast.engine.ASTInstructionCompiler

org.jibx.schema.codegen.SwitchBuilder

ptolemy.backtrack.eclipse.ast.transform.AssignmentTransformer

se.arnetheduck.j2c.transform.ImplWriter

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.