tools/pldt/org.eclipse.ptp.pldt.openmp.analysis/src/org/eclipse/ptp/pldt/openmp/analysis/ompcfg/OMPBasicBlock.java

/**********************************************************************
 * Copyright (c) 2006 IBM Corporation.
 * 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.ptp.pldt.openmp.analysis.ompcfg;

import java.util.Iterator;
import java.util.LinkedList;

import org.eclipse.cdt.core.dom.ast.ASTVisitor;
import org.eclipse.cdt.core.dom.ast.IASTBreakStatement;
import org.eclipse.cdt.core.dom.ast.IASTCaseStatement;
import org.eclipse.cdt.core.dom.ast.IASTCompoundStatement;
import org.eclipse.cdt.core.dom.ast.IASTContinueStatement;
import org.eclipse.cdt.core.dom.ast.IASTDoStatement;
import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.ast.IASTForStatement;
import org.eclipse.cdt.core.dom.ast.IASTIfStatement;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTReturnStatement;
import org.eclipse.cdt.core.dom.ast.IASTStatement;
import org.eclipse.cdt.core.dom.ast.IASTSwitchStatement;
import org.eclipse.cdt.core.dom.ast.IASTWhileStatement;



/**
 * Holds a consolidated (coarse) basic block for concurrency analysis
 * @author pazel
 */
public class OMPBasicBlock extends OMPCFGNode
{
    protected LinkedList     statements_ = new LinkedList();  // contained stmts 
    
    protected IASTName       label_      = null;   // non-null if labeled block
    
    protected IASTExpression branchingExpression_ = null;
    protected int            branchingType_       = NoBranch;
    
    public static final int NoBranch      = -1;
    public static final int IfBranch      = 0;
    public static final int SwitchBranch  = 1;
    public static final int WhileBranch   = 2;
    public static final int DoBranch      = 3;
    public static final int ForBranch     = 4;
    
    /**
     * OMPBasicBlock - Basic block for OMP CFG
     *
     */
    public OMPBasicBlock()
    {
        super();
    }
    
    /**
     * addStatement - add an element to this basic block
     * @param element - IASTNode
     */
    public void addStatement(IASTStatement element)
    {
        statements_.add(element);
    }
    
    public IASTName getLabel()
    {
        return label_;
    }
    
    /**
     * isCase - informs if first statement is a CASE 
     * @return boolean
     */
    public boolean isCase()
    {
        if (statements_.isEmpty())  return false;
        IASTStatement statement = ((IASTStatement)statements_.getFirst());
        return (statement instanceof IASTCaseStatement);
    }

    
    public void setBranchingExpression(IASTExpression branch, int type)
    {
        branchingExpression_ = branch;
        branchingType_       = type;
    }
    
    /**
     * getStatements - get the current list of statement for the node
     * @return IASTStatement []
     */
    public IASTStatement [] getStatements()
    {
        IASTStatement [] list = new IASTStatement[statements_.size()];
        int count = 0;
        for(Iterator i=statements_.iterator(); i.hasNext();)
            list[count++] = (IASTStatement)i.next();
        return list;
    }
    
    public IASTExpression getBranchingExpression() { return branchingExpression_; }
    public int            getBranchingType()       { return branchingType_;       }
    
    protected LinkedList fundStmtsExprs_ = null; 
    
    /**
     * getFundamentals - break down all statements/exprs to basics for concurrency map
     * @return
     */
    public LinkedList getFundamentals()
    {
        if (fundStmtsExprs_!=null) return fundStmtsExprs_;
        fundStmtsExprs_ = new LinkedList();
        
        for(Iterator i=statements_.iterator(); i.hasNext();) {
            IASTStatement stmt = (IASTStatement)i.next();
            FundVisitor fv = new FundVisitor(fundStmtsExprs_);
            stmt.accept(fv);
        }
        
        return fundStmtsExprs_;
    }
    
    //-------------------------------------------------------------------------
    // FundVisitor
    //-------------------------------------------------------------------------
    protected class FundVisitor extends ASTVisitor
    {
        protected LinkedList list_ = null;
        
        public FundVisitor(LinkedList list)
        {
            list_ = list;
            shouldVisitStatements = true;
        }
 
        public int visit(IASTStatement statement) {
            
            if (statement instanceof IASTIfStatement) {
                processIfStatement((IASTIfStatement)statement);
                return PROCESS_SKIP;
            }
            else if (statement instanceof IASTSwitchStatement) {
                processSwitchStatement((IASTSwitchStatement)statement);
                return PROCESS_SKIP;
            }
            else if (statement instanceof IASTCaseStatement) {
                processCaseStatement((IASTCaseStatement)statement);
                return PROCESS_CONTINUE;
            }
            else if (statement instanceof IASTForStatement) {
                processForStatement((IASTForStatement)statement);
                return PROCESS_SKIP;
            }
            else if (statement instanceof IASTWhileStatement) {
                processWhileStatement((IASTWhileStatement)statement);
                return PROCESS_SKIP;
            }
            else if (statement instanceof IASTDoStatement) {
                processDoStatement((IASTDoStatement)statement);
                return PROCESS_SKIP;
            }
            else if (statement instanceof IASTCompoundStatement) {
                return PROCESS_CONTINUE;
            }
            else if (statement instanceof IASTBreakStatement) {
                list_.add(statement);
                return PROCESS_CONTINUE;
            }
            else if (statement instanceof IASTContinueStatement) {
                list_.add(statement);
                return PROCESS_CONTINUE;
            }
            else if (statement instanceof IASTReturnStatement) {
                list_.add(statement);
                return PROCESS_CONTINUE;
            }
             
            list_.add(statement);
            return PROCESS_CONTINUE;
        }
        
        
        protected void processIfStatement(IASTIfStatement statement)
        {
            list_.add(statement.getConditionExpression());
            if (statement.getThenClause()!=null) {
                FundVisitor thenVisitor = new FundVisitor(list_);
                statement.getThenClause().accept(thenVisitor);
            }
            if (statement.getElseClause()!=null) {
                FundVisitor elseVisitor = new FundVisitor(list_);
                statement.getElseClause().accept(elseVisitor);
            }
        }
        
        protected void processSwitchStatement(IASTSwitchStatement statement)
        {
            list_.add(statement.getControllerExpression());
            FundVisitor  bodyVisitor = new FundVisitor(list_);
            statement.getBody().accept(bodyVisitor);
        }
        
        protected void processCaseStatement(IASTCaseStatement statement)
        {
            list_.add(statement.getExpression());
        }
        
        protected void processForStatement(IASTForStatement statement)
        {
            list_.add(statement.getConditionExpression());
            list_.add(statement.getIterationExpression());
            if (statement.getInitializerStatement()!=null) {
                FundVisitor  initVisitor = new FundVisitor(list_);
                statement.getInitializerStatement().accept(initVisitor);
            }
            if (statement.getBody()!=null) {
                FundVisitor  bodyVisitor = new FundVisitor(list_);
                statement.getBody().accept(bodyVisitor);
            }
        }
        
        protected void processWhileStatement(IASTWhileStatement statement)
        {
            list_.add(statement.getCondition());
            if (statement.getBody()!=null) {
                FundVisitor bodyVisitor = new FundVisitor(list_);
                statement.getBody().accept(bodyVisitor);
            }
        }
        
        protected void processDoStatement(IASTDoStatement statement)
        {
            list_.add(statement.getCondition());
            if (statement.getBody()!=null) {
                FundVisitor bodyVisitor = new FundVisitor(list_);
                statement.getBody().accept(bodyVisitor);
            }
        }


    }

}