/**********************************************************************
 * 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.factory;
import org.eclipse.ptp.pldt.openmp.analysis.OpenMPError;
import org.eclipse.ptp.pldt.openmp.analysis.OpenMPErrorManager;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTOMPPragma;
import org.eclipse.ptp.pldt.openmp.analysis.ompcfg.OMPCFG;
import org.eclipse.ptp.pldt.openmp.analysis.ompcfg.OMPCFGNode;
import org.eclipse.ptp.pldt.openmp.analysis.ompcfg.OMPDFS;
import org.eclipse.ptp.pldt.openmp.analysis.ompcfg.OMPPragmaNode;

/**
 * Look for common semantic errors
 * 
 * @author pazel
 *
 */
public class PASTSemanticCheck
{
    protected int numErrors_ = 0;
    
    protected PASTSemanticCheck(OMPCFG cfg)
    {
        SemanticDFS dfs = new SemanticDFS(cfg.getRoot());
        dfs.startWalking();
        
    }

    public static boolean checkSemantics(OMPCFG cfg)
    {
        PASTSemanticCheck psc = new PASTSemanticCheck(cfg);
        return psc.getNumErrors()==0 ? true : false;
    }
    
    public int getNumErrors()
    {
        return numErrors_;
    }
    
    private void checkPragmaSemantics(OMPPragmaNode pnode)
    {
        PASTOMPPragma pragma = pnode.getPragma();
        if (pragma==null)  // implicit barrier
            return;
        
        switch(pragma.getOMPType()) {
            // followed by structured region
            case PASTOMPPragma.OmpParallel:
               parallelCheck(pnode);
               break;
            case PASTOMPPragma.OmpSections:
            case PASTOMPPragma.OmpSection:
            case PASTOMPPragma.OmpParallelSections:
            case PASTOMPPragma.OmpSingle:
                break;
            case PASTOMPPragma.OmpMaster:
                masterCheck(pnode);
                break;
            case PASTOMPPragma.OmpCritical:
                break;
            case PASTOMPPragma.OmpOrdered:
                orderedCheck(pnode);
                break;
                
            // Must be followed by FOR
            case PASTOMPPragma.OmpFor:
            case PASTOMPPragma.OmpParallelFor:
                forCheck(pnode);
                break;

            // Stands alone
            case PASTOMPPragma.OmpBarrier:
                barrierCheck(pnode);
                break;
            case PASTOMPPragma.OmpFlush:
            case PASTOMPPragma.OmpThreadPrivate:
                break;
            
            // Followed by expression
            case PASTOMPPragma.OmpAtomic:
                break;
            case PASTOMPPragma.OmpUnknown:
                return;  
        }
        return;
    }
    
    /**
     * parallelCheck - semantic check for Parallel statements
     * @param pnode - OMPPragmaNode
     */
    private void parallelCheck(OMPPragmaNode pnode)
    {
        // A parallel directive dynamically inside another parallel
        // logically etablishes a new team which is composed of only the current thread,
        // unless nested parallelism is enabled.
        OMPPragmaNode parent = pnode.getContextPredecessor();
        while(parent!=null) {
            int pType = parent.getPragma().getOMPType();
            if (pType==PASTOMPPragma.OmpParallel ||
                pType==PASTOMPPragma.OmpParallelFor ||
                pType==PASTOMPPragma.OmpParallelSections) {
                handleProblem(pnode.getPragma(), 
                        "Parallel directive dynamically inside another parallel, establishes single thread context",
                        OpenMPError.WARN);
                numErrors_++;
                break;
            }
            parent = parent.getContextPredecessor();
        }
        return;
    }
    
    /**
     * forCheck - Semantic check for For/parallelFor semantic mistakes
     * @param pnode - OMPPragmaNode (for for/parallelFor)
     */
    private void forCheck(OMPPragmaNode pnode)
    {
        // A for directive is not allowed to nest with another for, sections, 
        // and single directive bound to the same parallel 
        // neither for ritical, ordered, and master regions
        PASTOMPPragma pragma = pnode.getPragma();
        boolean       isParallel = (pragma.getOMPType()==PASTOMPPragma.OmpParallelFor);
        OMPPragmaNode parent = pnode.getContextPredecessor();
        boolean       errorFound=false;
        while(parent!=null) {
            int parentType = parent.getPragma().getOMPType();
            if (!errorFound) { 
               if (parentType==PASTOMPPragma.OmpFor ||
                   parentType==PASTOMPPragma.OmpSections ||
                   parentType==PASTOMPPragma.OmpSingle) {
                 errorFound=true; 
               }
               else if (parentType==PASTOMPPragma.OmpCritical ||
                        parentType==PASTOMPPragma.OmpOrdered  ||
                        parentType==PASTOMPPragma.OmpMaster) {
                   handleProblem(pnode.getPragma(), 
                           "For directive embedded within critical, ordered, or master extents",
                           OpenMPError.ERROR);
                   numErrors_++;
                   errorFound=true;
                   break;
                }
               else if (parentType==PASTOMPPragma.OmpParallelFor ||
                        parentType==PASTOMPPragma.OmpParallelSections) {
                   handleProblem(pnode.getPragma(), 
                           "For directive embedded within another parallel for or parallel sections",
                           OpenMPError.ERROR);
                   numErrors_++;
                   errorFound=true;
                   break;
               }
               else if (isParallel && parentType==PASTOMPPragma.OmpParallel) {
                   handleProblem(pnode.getPragma(), 
                           "Parallel directive dynamically inside another parallel, establishes single thread context",
                           OpenMPError.WARN);
                   numErrors_++;
                   break;                 
               }
            }
            if (errorFound && (parentType==PASTOMPPragma.OmpParallel ||
                               parentType==PASTOMPPragma.OmpParallelFor ||
                               parentType==PASTOMPPragma.OmpParallelSections))
            {
                handleProblem(pnode.getPragma(), 
                        "For directive embedded within another for, sections, or single directive",
                        OpenMPError.ERROR);
                numErrors_++;
                break;
             }
            parent = parent.getContextPredecessor();
        }
        return;
    }
    
    /**
     * barrierCheck - semantic check on barrier statement
     * @param pnode - OMPPragmaNode
     */
    private void barrierCheck(OMPPragmaNode pnode)
    {
        // Barrier directives are not permitted in the dynamic extent of for, ordered, sections, single,
        // master, and critical regions
        OMPPragmaNode parent = pnode.getContextPredecessor();
        while(parent!=null) {
            int pType = parent.getPragma().getOMPType();
            if (pType==PASTOMPPragma.OmpFor || pType==PASTOMPPragma.OmpParallelFor ||
                pType==PASTOMPPragma.OmpOrdered || pType==PASTOMPPragma.OmpSections ||
                pType==PASTOMPPragma.OmpSingle  || pType==PASTOMPPragma.OmpMaster ||
                pType==PASTOMPPragma.OmpCritical) {
                handleProblem(pnode.getPragma(), 
                        "Barrier directive not permitted in region extent of for, ordered, sections, single, master, and critical",
                        OpenMPError.ERROR);
                numErrors_++;
                break;
             }
            parent = parent.getContextPredecessor();
        }
        return;
    }
    
    /**
     * masterCheck - semantic check for use of master directive
     * @param pnode - OMPPragmaNode
     */
    private void masterCheck(OMPPragmaNode pnode)
    {
        // Master directives are not permitted in the dynamic extent of 
        // for, sections, and single
        OMPPragmaNode parent = pnode.getContextPredecessor();
        while(parent!=null) {
            int pType = parent.getPragma().getOMPType();
            if (pType==PASTOMPPragma.OmpFlush || pType==PASTOMPPragma.OmpParallelFor ||
                pType==PASTOMPPragma.OmpSections || pType==PASTOMPPragma.OmpParallelSections ||
                pType==PASTOMPPragma.OmpSingle) {
                handleProblem(pnode.getPragma(), 
                        "Master directive not permitted in dynamic extent of for, sections, or single directives",
                        OpenMPError.ERROR);
                numErrors_++;
                break;
            }
            parent = parent.getContextPredecessor();
        }
        return;
    }
    
    /**
     * orderedCheck - semantic check on ordered directive
     * @param pnode - OMPPragmaNode
     */
    private void orderedCheck(OMPPragmaNode pnode)
    {
        // Ordered directives are not permitted in the dynamic extend of critical regions 
        OMPPragmaNode parent = pnode.getContextPredecessor();
        while(parent!=null) {
            int pType = parent.getPragma().getOMPType();
            if (pType==PASTOMPPragma.OmpCritical) {
                handleProblem(pnode.getPragma(), 
                        "Ordered directive not permitted in dynamic extent of critical region",
                        OpenMPError.ERROR);
                numErrors_++;
                break;
            }
            parent = parent.getContextPredecessor();
        }
        return;
    }
    
    
    /**
     * handleProblem
     * @param description - String
     * @param severity    - int
     */
    private void handleProblem(PASTOMPPragma pragma, String  description, int severity)
    {
        OpenMPError error = new OpenMPError(description, 
                                            pragma.getContainingFilename(),
                                            pragma.getStartingLine(),
                                            severity);
        OpenMPErrorManager.getCurrentErrorManager().addError(error);
        pragma.addProblem(error);  // we really don't need this, but may be useful later
    }

    
    private class SemanticDFS extends OMPDFS
    {
        
        public SemanticDFS(OMPCFGNode startNode)
        {
            super(startNode);
        }


        public int visit(OMPCFGNode node)
        {
            if (node instanceof OMPPragmaNode) 
                checkPragmaSemantics((OMPPragmaNode)node);
            return 0;
        }
        
    }

}