/**********************************************************************
 * Copyright (c) 2006, 2007 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.PAST;

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

import org.eclipse.cdt.core.dom.ast.ASTVisitor;
import org.eclipse.cdt.core.dom.ast.IASTCompoundStatement;
import org.eclipse.cdt.core.dom.ast.IASTFileLocation;
import org.eclipse.cdt.core.dom.ast.IASTForStatement;
import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition;
import org.eclipse.cdt.core.dom.ast.IASTNode;
import org.eclipse.cdt.core.dom.ast.IASTStatement;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.IScope;
import org.eclipse.cdt.core.parser.IToken;
import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;
import org.eclipse.cdt.internal.core.dom.parser.ASTNode;
import org.eclipse.cdt.internal.core.dom.parser.c.CScope;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPScope;
import org.eclipse.jface.text.IDocument;
import org.eclipse.ptp.pldt.common.util.Utility;
import org.eclipse.ptp.pldt.openmp.analysis.OpenMPError;
import org.eclipse.ptp.pldt.openmp.analysis.OpenMPErrorManager;
import org.eclipse.ptp.pldt.openmp.analysis.dictionary.Dictionary;
import org.eclipse.ptp.pldt.openmp.analysis.dictionary.Symbol;
import org.eclipse.ptp.pldt.openmp.analysis.parser.OpenMPScanner;
import org.eclipse.ptp.pldt.openmp.analysis.parser.OpenMPToken;

/**
 * Factory to convert PASTPragma-->PASTOMPPragma
 * @author pazel
 *
 */
public class PASTOMPFactory
{
    protected PASTPragma          pragma_       = null;
    protected PASTOMPPragma       ompPragma_    = null;
    protected IASTTranslationUnit ast_          = null;
    protected Dictionary          dictionary_   = null;
    
    protected static boolean      traceOn_      = false;
    private static final boolean traceOn=false;
    
    protected OpenMPScanner scanner_ = null;
    protected OpenMPToken   token_   = null;
    
    //protected ScannerCallbackManager callbackManager_ = null;
    
    /**
     * Factory used only by this class
     * @param pragma - PASTPragma
     */
    protected PASTOMPFactory(PASTPragma          pragma, 
                             IASTTranslationUnit ast,
                             Dictionary          dictionary)
    {
        pragma_     = pragma;
        scanner_    = new OpenMPScanner(pragma_.getContent());
        ast_        = ast;
        dictionary_ = dictionary;
        
        //experiment();
        
        if (traceOn_)
          readTokens();
        
        //otherinit(null);
    }
    
    private void experiment()
    {
        IASTFileLocation loc = pragma_.getFileLocation();
        if (loc!=null) {
            IDocument document = Utility.getDocument(loc.getFileName());
            if (document != null) {
                try {
                  String txt = document.get(pragma_.getLocalOffset(), pragma_.getLength());
                  System.out.println(txt);
                }
                catch(Exception e) {}
            }
        }
    }

    
    /**
     * Return either omp or non-omp pragma
     * @return
     */
    protected PASTPragma retrievePragma()
    {
        return (ompPragma_!=null ? ompPragma_ : pragma_);
    }
    
    /**
     * Factory for making the PASTOMPPragma structure
     *               if possible
     * @param pragma     : PASTPragma 
     * @param ast        : IASTTranslationUnit
     * @param dictionary : Dictionary
     * @return: PASTPragma (or PASTOMPPragma if do-able)
     */
    public static PASTPragma makePASTOMP(PASTPragma          pragma, 
                                         IASTTranslationUnit ast, 
                                         Dictionary          dictionary)
    {
        PASTOMPFactory factory = new PASTOMPFactory(pragma, ast, dictionary);
        factory.parse();
        factory.locateRegion();
        return factory.retrievePragma();
    }
    
    /**
     * Parse the pragma context for OMP
     * @return boolean
     */
    protected boolean parse() 
    {
        // The first two tokens should be # and pragma
    	OpenMPToken tok=nextToken();
    	if(tok==null){
    		if(traceOn)System.out.println("PASTOMPFactory.parser()..null token, ignored.");
    		return false; //robustly handle empty tokens
    	}
        if (tok.getType()!=OpenMPScanner.mpPound) return false;
        tok=nextToken();
        if (tok.getType()!=OpenMPScanner.mpPragma) return false;
        
        // if next is not omp - this is not an openmp directive
        if (nextToken().getType()!=OpenMPScanner.mpOmp) 
            return false;
        
        // Construct the OpenMP pragma
        ompPragma_ = new PASTOMPPragma(pragma_);
        
        // The next token sets the type
        nextToken();
        OpenMPToken typeToken = token_;   // determines type, used for error message
        if (token_==null)  return false;
        ompPragma_.setOMPType(setOMPType(token_.getType()));
        
        if (token_==null)  return false;
        
        switch(ompPragma_.getOMPType()) {
            case PASTOMPPragma.OmpParallel:
                completeParallel();
                break;
            case PASTOMPPragma.OmpFor:
                completeFor();
                break;
            case PASTOMPPragma.OmpParallelFor:
                completeParallelFor();
                break;
            case PASTOMPPragma.OmpSections:
                completeSections();
                break;
            case PASTOMPPragma.OmpParallelSections:
                completeParallelSections();
                break;
            case PASTOMPPragma.OmpSingle:
                completeSingle();
                break;
            case PASTOMPPragma.OmpMaster:
                break;
            case PASTOMPPragma.OmpCritical:
                break;
            case PASTOMPPragma.OmpBarrier:
                break;
            case PASTOMPPragma.OmpAtomic:
                break;
            case PASTOMPPragma.OmpSection:
                break;
            case PASTOMPPragma.OmpFlush:
                completeFlush();
                break;
            case PASTOMPPragma.OmpOrdered:
                break;
            case PASTOMPPragma.OmpThreadPrivate:
                completeThreadPrivate();
                break;
            case PASTOMPPragma.OmpUnknown:
                String typeString = (typeToken!=null ? typeToken.getImage(): "");
                handleProblem("Unexpected token '"+typeString+"'", OpenMPError.ERROR);
                break;
        }
        
        // all remaining tokens are bogus
        while(token_!=null) {
            handleProblem("Unexpected token '"+token_.getImage()+"'", OpenMPError.ERROR);
            nextToken();
        }
        
        return true;
    }
    
    /**
     * Set the type of OpenMP statement based on keyword
     * @param t
     * @return
     *    Note: always exit with the current token being the next to process, i.e.
     *          call nextToken()
     */
    protected int setOMPType(int t)
    {
       nextToken();    // advance to next token 
       switch(t) {
           case OpenMPScanner.mpParallel:
               if (token_==null) return PASTOMPPragma.OmpParallel;
               if (token_.getType()==OpenMPScanner.mpFor) {
                   nextToken(); return PASTOMPPragma.OmpParallelFor;
               }
               else if (token_.getType()==OpenMPScanner.mpSections) {
                   nextToken(); return PASTOMPPragma.OmpParallelSections;
               }
               return PASTOMPPragma.OmpParallel;
           case OpenMPScanner.mpFor:
               return PASTOMPPragma.OmpFor;
           case OpenMPScanner.mpSections:
               return PASTOMPPragma.OmpSections;
           case OpenMPScanner.mpSection:
               return PASTOMPPragma.OmpSection;
           case OpenMPScanner.mpSingle:
               return PASTOMPPragma.OmpSingle;
           case OpenMPScanner.mpMaster:
               return PASTOMPPragma.OmpMaster;
           case OpenMPScanner.mpCritical:
               return PASTOMPPragma.OmpCritical;
           case OpenMPScanner.mpBarrier:
               return PASTOMPPragma.OmpBarrier;
           case OpenMPScanner.mpAtomic:
               return PASTOMPPragma.OmpAtomic;
           case OpenMPScanner.mpFlush:
               return PASTOMPPragma.OmpFlush;
           case OpenMPScanner.mpOrdered:
               return PASTOMPPragma.OmpOrdered;
           case OpenMPScanner.mpThreadPrivate:
               return PASTOMPPragma.OmpThreadPrivate;
       }
       return PASTOMPPragma.OmpUnknown;
    }
    
    /**
     * Parse a list of identifiers, e.g. as from shared(...)
     * @return OpenMPToken []
     */
    protected OpenMPToken [] getIdentifierList()
    {
        LinkedList l = new LinkedList();
        
        if (token_==null)  return null;
        //if (token_.getType()!=IToken.tLPAREN) return null;
        
        // look for lists like a,b,c
        boolean commaNext = false;
        nextToken();
        while(token_!=null) {
           if (commaNext) {
               if (token_.getType()!=IToken.tCOMMA)   break; 
               else  { commaNext=false;  nextToken(); continue; }
           }
           // whatever it is, add to the list
           l.add(token_);
           commaNext=true;
           nextToken();
        }
        
        // build the list
        OpenMPToken [] ompl = new OpenMPToken[l.size()];
        int count=0;
        for(Iterator i = l.iterator(); i.hasNext();) {
            ompl[count++] = (OpenMPToken)i.next();
            // check to see if in dictionary
            Symbol [] symbols = dictionary_.getSymbolsFor(ompl[count-1].getImage());
            if (symbols.length==0) {
                handleProblem("Undefined symbol '"+ompl[count-1].getImage()+"'", OpenMPError.ERROR);  
            }
            else {
                // try to find at least one (non-global that is in same scope as pragma
                boolean found=false;
                for(int j=0; j<symbols.length; j++) {
                    IASTNode fctn = symbols[j].getDefiningFunction();
                    if (fctn==null || !(fctn instanceof IASTFunctionDefinition)) continue;
                    if (isSymbolRelevant(symbols[j])) { found=true; break; }
                }
                if (!found)
                    handleProblem("Symbol out of scope: '"+ompl[count-1].getImage()+"'", OpenMPError.ERROR); 
            }
        }
        
        // rule: always leave one ahead
        nextToken();
        
        return ompl;
    }
    
    /**
     * See if symbol is a local variable in scope to pragma
     * @param symbol - Symbol
     * @return boolean
     */
    protected boolean isSymbolRelevant(Symbol symbol)
    {   
    	if(traceOn)System.out.println("Symbol: "+symbol.getName()+"  PASTOMPFactory.isSymbolRelevant()");
        IASTNode node = null;
        IASTNode parent,gp=null;
		try {
			// node=symbol.getScope().getPhysicalNode(); // no longer in CDT 4.0
			// BRT replacement for getPhysicalNode() for CDT 4.0
			// The following probably isn't an ideal solution (using Discouraged access methods)
			// but seems to work for now. 
			// alternatively I tried implementing: symbol.getPhysicalNode() but could not get the same answer from there.
			
			IScope scope=symbol.getScope();
			// see: http://dev.eclipse.org/mhonarc/lists/cdt-dev/msg08653.html
			// Another alternative would be to cast to CScope and do cScope.getPhysicalNode() from there.
			node = ASTInternal.getPhysicalNodeOfScope(scope);

		} catch (Exception e) {
			return false;
		}
        
        Utility.Location l = Utility.getLocation(node);
        int nodeOffset = (l!=null ? l.getLow()  : 0);     //728
        int nodeEndset = (l!=null ? l.getHigh() : 0);       //745
        if(traceOn)System.out.println("node: "+node.getRawSignature()+" nodeOffset: "+nodeOffset+" nodeEndset= "+nodeEndset);
        
        int pOffset = pragma_.getLocalOffset();            //822
        int pEndset = pOffset+pragma_.getLength()-1;       //864
        if(traceOn)System.out.println(("pragma pOffset= "+pOffset+" pEndset= "+pEndset));
        
        boolean tf = ((nodeEndset<pOffset || pEndset<nodeOffset) ? false : true);  //false
        if (!tf)  return tf;
        
        // See if the declaration succeeds the pragma
        Utility.Location dl = Utility.getLocation(symbol.getDeclarator());
        if (dl==null)  return false;
        if(traceOn)System.out.println("dl.getLow()="+dl.getLow()+" pOffset="+pOffset+
        		" > is: "+(dl.getLow()>pOffset));
        
        return (dl.getLow()>pOffset ? false : true);
    }
    
    /**
     * Acquire the next token
     * @return OpenMPToken
     */
    protected OpenMPToken nextToken()
    {
        // Following in case of backup
        if (token_!=null && token_.getNext()!=null) {
            token_ = token_.getNext();
            return token_;
        }
        
        // chain to last one and move on
        OpenMPToken token = scanner_.nextToken();
        if (token_!=null)
            token_.setNext(token);
        token_ = token;
        return token_;
    }
    
    /**
     * Get current token so as to mark (in code) where we were
     * @return OpenMPToken
     */
    protected OpenMPToken mark()
    {
        if (token_==null)
            token_ = nextToken();
        return token_;
    }
    
    /**
     * Reset token queue (nextToken() get one after this one)
     * @param token
     */
    protected void backupTo(OpenMPToken token)
    {
        token_ = token;
    }
    
    /**
     * Test the parser
     *
     */
    private void readTokens()
    {
        OpenMPScanner scanner = new OpenMPScanner(pragma_.getContent());
        
        OpenMPToken token = null;
        do {
            token = scanner.nextToken();
            if (token!=null)
              System.out.println("Token:"+token.getImage()+" type="+token.getType());
         } while(token!=null);
    }
    
    /**
     * Complete the parsing of #pragma omp parallel
     *
     */
    private void completeParallel()
    {
        boolean bShared       = false;
        boolean bPrivate      = false;
        boolean bFirstPrivate = false;
        boolean bDefault      = false;
        boolean bReduction    = false;
        boolean bCopyin       = false;
        boolean bIf           = false;
        boolean bNumthreads   = false;
        
        while(token_!=null) {
            switch(token_.getType()){
                case OpenMPScanner.mpShared:
                    if (!bShared) 
                        bShared = setShared();
                    break;
                case OpenMPScanner.mpPrivate:
                    if (!bPrivate) 
                        bPrivate = setPrivate();
                    break;
                case OpenMPScanner.mpFirstprivate:
                    if (!bFirstPrivate) 
                        bFirstPrivate = setFirstPrivate();
                    break;
               case OpenMPScanner.mpDefault:
                    if (!bDefault)
                        bDefault = setDefault();
                    break;
               case OpenMPScanner.mpReduction:
                   if (!bReduction)
                       bReduction = setReduction();
                   break;
               case OpenMPScanner.mpCopyin:
                   if (!bCopyin) 
                       bCopyin = setCopyin();
                   break;
               case OpenMPScanner.mpIf:
                   if (!bIf)  
                       bIf = setIf();
                   break;
               case OpenMPScanner.mpNumthreads:
                   if (!bNumthreads)
                       bNumthreads = setNumThreads();
                   break;
               default:
                   handleProblem("Unexpected token "+token_.getImage(), OpenMPError.ERROR);
                   nextToken();
                   break;
            }
        }
    }
    
    /**
     * Complete parsing #paragma omp for
     *
     */
    private void completeFor()
    {
        boolean bPrivate      = false;
        boolean bFirstPrivate = false;
        boolean bLastPrivate  = false;
        boolean bReduction    = false;
        boolean bOrdered      = false;
        boolean bSchedule     = false;
        boolean bNowait       = false;
        
        while(token_!=null) {
            switch(token_.getType()){
                case OpenMPScanner.mpPrivate:
                    if (!bPrivate)
                        bPrivate = setPrivate();
                    break;
                case OpenMPScanner.mpFirstprivate:
                    if (!bFirstPrivate) 
                        bFirstPrivate = setFirstPrivate();
                    break;
                case OpenMPScanner.mpLastprivate:
                    if (!bLastPrivate)  
                        bLastPrivate = setLastPrivate(); 
                    break;
                case OpenMPScanner.mpReduction:
                    if (!bReduction)
                        bReduction = setReduction();
                  break;
                case OpenMPScanner.mpOrdered:
                    if (!bOrdered) {
                      ompPragma_.setOrdered(true);  bOrdered=true; }
                    nextToken();
                    break;
                case OpenMPScanner.mpSchedule:
                    if (!bSchedule)
                        bSchedule = setSchedule();
                    break;
                case OpenMPScanner.mpNowait:
                    if (!bNowait) {
                        ompPragma_.setNoWait(true);  bNowait=true;  }
                    nextToken();
                    break;
                default:
                    handleProblem("Unexpected token "+token_.getImage(), OpenMPError.ERROR);
                    nextToken();
                    break;
            }
        }
    }
    
    
    /**
     * Complete parsing #paragma omp parallel for
     *
     */
    private void completeParallelFor()
    {
        boolean bShared       = false;
        boolean bPrivate      = false;
        boolean bFirstPrivate = false;
        boolean bLastPrivate  = false;
        boolean bDefault      = false;
        boolean bReduction    = false;
        boolean bCopyin       = false;
        boolean bIf           = false;
        boolean bOrdered      = false;
        boolean bSchedule     = false;
        
        while(token_!=null) {
            switch(token_.getType()){
                case OpenMPScanner.mpShared:
                    if (!bShared) 
                        bShared = setShared();
                    break;
                case OpenMPScanner.mpPrivate:
                    if (!bPrivate)
                        bPrivate = setPrivate();
                    break;
                case OpenMPScanner.mpFirstprivate:
                    if (!bFirstPrivate) 
                        bFirstPrivate = setFirstPrivate();
                    break;
                case OpenMPScanner.mpLastprivate:
                    if (!bLastPrivate)  
                        bLastPrivate = setLastPrivate(); 
                    break;
                case OpenMPScanner.mpDefault:
                    if (!bDefault)
                        bDefault = setDefault();
                    break;
                case OpenMPScanner.mpReduction:
                    if (!bReduction)
                        bReduction = setReduction();
                  break;
                case OpenMPScanner.mpCopyin:
                    if (!bCopyin) 
                        bCopyin = setCopyin();
                    break;
                case OpenMPScanner.mpIf:
                    if (!bIf)  
                        bIf = setIf();
                    break;
                case OpenMPScanner.mpOrdered:
                    if (!bOrdered) {
                      ompPragma_.setOrdered(true);  bOrdered=true; }
                    nextToken();
                    break;
                case OpenMPScanner.mpSchedule:
                    if (!bSchedule)
                        bSchedule = setSchedule();
                    break;
                default:
                    handleProblem("Unexpected token "+token_.getImage(), OpenMPError.ERROR);
                    nextToken();
                    break;
            }
        }
    }
    
    
    /**
     * Complete parsing #pragma omp parallel sections
     *
     */
    private void completeParallelSections()
    {
        boolean bShared       = false;
        boolean bPrivate      = false;
        boolean bFirstPrivate = false;
        boolean bLastPrivate  = false;
        boolean bDefault      = false;
        boolean bReduction    = false;
        boolean bCopyin       = false;
        boolean bIf           = false;
        
        while(token_!=null) {
            switch(token_.getType()){
                case OpenMPScanner.mpShared:
                    if (!bShared) 
                        bShared = setShared();
                    break;
                case OpenMPScanner.mpPrivate:
                    if (!bPrivate)
                        bPrivate = setPrivate();
                    break;
                case OpenMPScanner.mpFirstprivate:
                    if (!bFirstPrivate) 
                        bFirstPrivate = setFirstPrivate();
                    break;
                case OpenMPScanner.mpLastprivate:
                    if (!bLastPrivate)  
                        bLastPrivate = setLastPrivate(); 
                    break;
                case OpenMPScanner.mpDefault:
                    if (!bDefault)
                        bDefault = setDefault();
                    break;
                case OpenMPScanner.mpReduction:
                    if (!bReduction)
                        bReduction = setReduction();
                  break;
                case OpenMPScanner.mpCopyin:
                    if (!bCopyin) 
                        bCopyin = setCopyin();
                    break;
                case OpenMPScanner.mpIf:
                    if (!bIf)  
                        bIf = setIf();
                    break;
                default:
                    handleProblem("Unexpected token "+token_.getImage(), OpenMPError.ERROR);
                    nextToken();
                    break;
            }
        }
    }

    
    /**
     * Complete parse of #pragma omp sections
     *
     */
    private void completeSections()
    {
        boolean bPrivate      = false;
        boolean bFirstPrivate = false;
        boolean bLastPrivate  = false;
        boolean bReduction    = false;
        boolean bNowait       = false;
        
        while(token_!=null) {
            switch(token_.getType()){
                case OpenMPScanner.mpPrivate:
                    if (!bPrivate)
                        bPrivate = setPrivate();
                     break;
                case OpenMPScanner.mpFirstprivate:
                    if (!bFirstPrivate) 
                        bFirstPrivate = setFirstPrivate();
                   break;
                case OpenMPScanner.mpLastprivate:
                    if (!bLastPrivate)  
                        bLastPrivate = setLastPrivate(); 
                    break;
                case OpenMPScanner.mpReduction:
                    if (!bReduction)
                        bReduction = setReduction();
                    break;
                case OpenMPScanner.mpNowait:
                    if (!bNowait) {
                        ompPragma_.setNoWait(true);  bNowait=true;  }
                    nextToken();
                    break;
                 default:
                    handleProblem("Unexpected token "+token_.getImage(), OpenMPError.ERROR);
                    nextToken();
                    break;
            }
        }
        
    }
    
    /**
     * Complete options for the #pragma omp single
     *
     */
    private void completeSingle()
    {
        boolean bPrivate      = false;
        boolean bFirstPrivate = false;
        boolean bCopyPrivate  = false;
        boolean bNowait       = false;
        
        while(token_!=null) {
            switch(token_.getType()){
                case OpenMPScanner.mpPrivate:
                    if (!bPrivate)
                        bPrivate = setPrivate();
                   break;
                case OpenMPScanner.mpFirstprivate:
                    if (!bFirstPrivate) 
                        bFirstPrivate = setFirstPrivate();
                    break;
                case OpenMPScanner.mpCopyprivate:
                    if (!bCopyPrivate) 
                       bCopyPrivate = setCopyPrivate();
                    break;
                case OpenMPScanner.mpNowait:
                    if (!bNowait) {
                        ompPragma_.setNoWait(true);  bNowait=true;  }
                    nextToken();
                    break;
                default:
                    handleProblem("Unexpected token "+token_.getImage(), OpenMPError.ERROR);
                    nextToken();
                    break;
            }
        }
        
    }
    
    /**
     * Complete the options for the #pragma omp flush
     *
     */
    private void completeFlush()
    {
        if (token_==null || token_.getType()!=IToken.tLPAREN)  return;
        
        OpenMPToken []   list = getIdentifierList();
        
        ompPragma_.setPrivateList(list);
    }

    
    /**
     * Complete the options for the #pragma omp threadprivate
     *
     */
    private void completeThreadPrivate()
    {
        if (token_==null || token_.getType()!=IToken.tLPAREN)  return;
        
        OpenMPToken []   list = getIdentifierList();
        
        ompPragma_.setThreadPrivateList(list);
    }
    
    /**
     * Translate the type of reduction operato
     * @return int (that PASTOMPPragma understands)
     */
    private int getReductionOperator()
    {
        switch(token_.getType()) {
            case IToken.tPLUS:
                return PASTOMPPragma.OmpOpPlus;
            case IToken.tSTAR:
                return PASTOMPPragma.OmpOpMult;
            case IToken.tMINUS:
                return PASTOMPPragma.OmpOpMinus;
            case IToken.tAMPER:
                return PASTOMPPragma.OmpOpBAnd;
            case IToken.tXOR:
                return PASTOMPPragma.OmpOpBXor;
            case IToken.tBITOR:
                return PASTOMPPragma.OmpOpBOr;
            case IToken.tAND:
                return PASTOMPPragma.OmpOpLAnd;
            case IToken.tOR:
                return PASTOMPPragma.OmpOpLOr;
            default:
                return PASTOMPPragma.OmpOpUnknown;
        }
    }
    
    /**
     * Translate the kind of schedule
     * @return int (that PASTOMPPragma understands)
     */
    private int getScheduleKind()
    {
        switch(token_.getType()) {
            case OpenMPScanner.mpStatic:
                return PASTOMPPragma.OmpSKStatic;
            case OpenMPScanner.mpDynamic:
                return PASTOMPPragma.OmpSKDynamic;
            case OpenMPScanner.mpGuided:
                return PASTOMPPragma.OmpSKGuided;
            case OpenMPScanner.mpRuntime:
                return PASTOMPPragma.OmpSKRuntime;
            default:
                return PASTOMPPragma.OmpSKUnknown;
        }
    }
    
    /**
     * Get the schedule expression
     * @return OpenMPToken []
     */
    private OpenMPToken [] getExpression()
    {
        LinkedList l = new LinkedList();
        int        parenCt=1;
        
        nextToken();
        while(token_!=null) {
            if (token_.getType()==IToken.tRPAREN){
                parenCt--;  if (parenCt==0)  break;  
                            else {l.add(token_); }  // end of schedule clause
            }
            else if (token_.getType()==IToken.tCOMMA) {
                if (parenCt==1)  break; else l.add(token_);               // another way to exit
            }
            else if (token_.getType()==IToken.tLPAREN) 
            { parenCt++;  l.add(token_);  }
            else 
                l.add(token_);
            nextToken();
        }
        
        OpenMPToken [] list = new OpenMPToken[l.size()];
        for(int i=0; i<l.size(); i++)
            list[i] = (OpenMPToken)l.get(i);
        
        nextToken();   // move ahead
        return list;
    }
    
    private boolean setIf()
    {
        nextToken();
        OpenMPToken [] list = getExpression();
        ompPragma_.setIfExpression(list); 
        return true;
    }
    
    
    private boolean setPrivate()
    {
        nextToken();
        OpenMPToken [] list = getIdentifierList();
        ompPragma_.setPrivateList(list); 
        return true;
    }
    
    private boolean setFirstPrivate()
    {
        nextToken();
        OpenMPToken [] list = getIdentifierList();
        ompPragma_.setFirstPrivateList(list); 
        return true;
    }
    
    private boolean setLastPrivate()
    {
        nextToken();
        OpenMPToken [] list = getIdentifierList();
        ompPragma_.setLastPrivateList(list); 
        return true;
    }
   
    private boolean setShared()
    {
        nextToken();
        OpenMPToken [] list = getIdentifierList();
        ompPragma_.setSharedList(list); 
        return true;
    }
    
    private boolean setCopyin()
    {
       nextToken();
       OpenMPToken [] list = getIdentifierList();
       ompPragma_.setCopyinList(list); 
       return true;
    }
    
    
    private boolean setCopyPrivate()
    {
       nextToken();
       OpenMPToken [] list = getIdentifierList();
       ompPragma_.setCopyPrivateList(list); 
       return true;
    }

    
    private boolean setDefault()
    {
        boolean shared = false;
        nextToken();
        if (token_.getType()==IToken.tLPAREN) {
            nextToken();
            if (token_.getType()==OpenMPScanner.mpShared)    shared=true;
            else if (token_.getType()==OpenMPScanner.mpNone) shared=false;
            else return false;
            nextToken();  // get the paren
            if (token_==null || token_.getType()!=IToken.tRPAREN)  return false;
            ompPragma_.setDefault(shared ? PASTOMPPragma.OmpShared : 
                                           PASTOMPPragma.OmpNone);
            nextToken();
            return true;
        }
        return false;
    }
    
    private boolean setReduction()
    {
        nextToken();
        if (token_.getType()==IToken.tLPAREN) {
            nextToken();
            int ro = getReductionOperator();
            nextToken();
            if (token_!=null && token_.getType()==IToken.tCOLON) {
                OpenMPToken [] rlist = getIdentifierList();
                ompPragma_.setReductionOperator(ro);
                ompPragma_.setReductionList(rlist);  
                return true;
            }
            return false;
        }
        return false;
    }
    
    private boolean setNumThreads()
    {
        nextToken();
        if (token_.getType()==IToken.tLPAREN) {
            OpenMPToken [] expr = getExpression();
            if (token_==null || token_.getType()!=IToken.tRPAREN) return false;
            ompPragma_.setNumThreadsExpr(expr);
            return true;
        }
        return false;
    }
    
    private boolean setSchedule()
    {
        nextToken();
        if (token_.getType()==IToken.tLPAREN) {
            nextToken();
            int kind = getScheduleKind();
            nextToken();
            if (token_!=null && token_.getType()==IToken.tCOMMA) {
                OpenMPToken [] expr = getExpression();
                ompPragma_.setScheduleKind(kind);
                ompPragma_.setChunkExpression(expr);
                return true;
            }
            return false;
        }
        return false;
    }
    
    
    // We are presently unsure of what to do with all the following stuff:
//    protected static final ScannerProblemFactory spf = new ScannerProblemFactory();
//    protected ScannerCallbackManager callbackManager;
//    protected static char[] EMPTY_CHAR_ARRAY = new char[0];
//    
//    protected void otherinit(ISourceElementRequestor requestor)
//    {
//        callbackManager = new ScannerCallbackManager(new NullSourceElementRequestor());
//    }
    
    /**
     * handleProblem
     * @param description - String
     * @param severity    - int
     */
    protected void handleProblem(String  description, int severity)
    {
        OpenMPError error = new OpenMPError(description, 
                                            pragma_.getContainingFilename(),
                                            pragma_.getStartingLine(),
                                            severity);
        OpenMPErrorManager.getCurrentErrorManager().addError(error);
        ompPragma_.addProblem(error);  // we really don't need this, but may be useful later
    }
    
    /**
     * lFind the associated region to the current pragma
     *
     */
    private void locateRegion()
    {
        if (ompPragma_==null)  return;
        
        switch (ompPragma_.getOMPType()) {
            // followed by structured region
            case PASTOMPPragma.OmpParallel:
            case PASTOMPPragma.OmpSections:
            case PASTOMPPragma.OmpSection:
            case PASTOMPPragma.OmpParallelSections:
            case PASTOMPPragma.OmpSingle:
            case PASTOMPPragma.OmpMaster:
            case PASTOMPPragma.OmpCritical:
            case PASTOMPPragma.OmpOrdered:
                determineRegion(STRUCTURED_BLOCK, ompPragma_);
                break;
                
            // Must be followed by FOR
            case PASTOMPPragma.OmpFor:
            case PASTOMPPragma.OmpParallelFor:
                determineRegion(FOR_BLOCK, ompPragma_);
                break;

            // Stands alone
            case PASTOMPPragma.OmpBarrier:
            case PASTOMPPragma.OmpFlush:
            case PASTOMPPragma.OmpThreadPrivate:
                determineRegion(LOCATION_ONLY, ompPragma_);
                break;
            
            // Followed by expression
            case PASTOMPPragma.OmpAtomic:
                determineRegion(EXPRESSION_BLOCK, ompPragma_);
                break;
            case PASTOMPPragma.OmpUnknown:
                break;
        }
    }
    
    public static final int STRUCTURED_BLOCK   = RegionDeterminationVisitor.STRUCTURED_BLOCK;
    public static final int FOR_BLOCK          = RegionDeterminationVisitor.FOR_BLOCK;
    public static final int EXPRESSION_BLOCK   = RegionDeterminationVisitor.EXPRESSION_BLOCK;
    public static final int LOCATION_ONLY      = RegionDeterminationVisitor.LOCATION_ONLY;
    
    /**
     * Determine that code region affilated with a pragma & the peer node
     * @param type - int (see constatns above)
     * @param ompPragma - PASTOMPPragma
     */
    protected void determineRegion(int type, PASTOMPPragma ompPragma)
    {
        RegionDeterminationVisitor rdv = new RegionDeterminationVisitor(type, ompPragma);
        ast_.accept(rdv);
        
        // Ensure that region for structured block is a compound statement
        if (type==STRUCTURED_BLOCK) {
            IASTNode region = ompPragma.getRegion();
            if (region==null || !(region instanceof IASTCompoundStatement))
                handleProblem("Pragma expects structured block to follow it", OpenMPError.ERROR);
        }
        else if (type==FOR_BLOCK) {
            IASTNode region = ompPragma.getRegion();
            if (region==null || !(region instanceof IASTForStatement))
                handleProblem("Pragma expects for loop to follow it", OpenMPError.ERROR);
        }
    }
    
   
    /**
     * RegionDeterminationVisitor is used to traverse AST to find region
     */
    protected class RegionDeterminationVisitor extends ASTVisitor
    {
        protected int           searchType_        = STRUCTURED_BLOCK;
        protected PASTOMPPragma oPragma_           = null; 
        protected int           pragmaLine_        = 0;
        protected int           pragmaLocation_    = 0;
        protected int           pragmaLength_      = 0;
        
        protected int           closeness_         = -1;
        
        // for statement location
        //protected IASTStatement lastStatement_ = null;
        
        public final static int STRUCTURED_BLOCK   = 0;
        public final static int FOR_BLOCK          = 1;
        public final static int EXPRESSION_BLOCK   = 2;
        public final static int LOCATION_ONLY      = 3;  // tell me what immediately precedes
        
        public RegionDeterminationVisitor(int type, PASTOMPPragma ompPragma)
        {
            searchType_ = type; 
            switch(searchType_) {
                case STRUCTURED_BLOCK:
                    shouldVisitStatements = true;
                    break;
                case FOR_BLOCK:
                    shouldVisitStatements = true;                    
                    break;
                case EXPRESSION_BLOCK:
                    shouldVisitStatements = true;    // we want an expression statement
                    break;
                case LOCATION_ONLY:
                    shouldVisitStatements = true;
                    break;
            }
            
            oPragma_        = ompPragma;
            pragmaLine_     = oPragma_.getStartingLine();
            pragmaLocation_ = oPragma_.getOffset(); //oPragma_.getStartLocation();
            pragmaLength_   = oPragma_.getLength();
        }
        
        /**
         * override function to visit statements implementation
         *         NOTE: Region is first statement following pragma
         * 
         * @param statement - IASTStatement
         * @return int
         */
        public int visit(IASTStatement statement) {
            ASTNode node = (statement instanceof ASTNode ? (ASTNode)statement : null);
            if (node==null)  return PROCESS_CONTINUE;
            
            // ensure the node is in the same file as the pragma
            if (node.getContainingFilename().equals(oPragma_.getFileLocation().getFileName())) {
              int              totalOffset = node.getOffset();
              Utility.Location loc = Utility.getLocation(node);
              assert(loc!=null);
              int localOffset = loc.getLow();  // this is the offset local to the file
              int length      = loc.getHigh()-loc.getLow()+1;
              
              // We look at all nodes that occur before the pragma - 2 cases
              // 1) if the node scope encompases the pragam, pragma is a child of node
              // 2) otherwise we call it a peer (even when it isn't)
              // Corrections occur by continuing for the tightest fit
              if (totalOffset<pragmaLocation_) {
                  if (pragmaLocation_+pragmaLength_<totalOffset+length) { // encompassing
                      oPragma_.setLocation(statement, PASTOMPPragma.ChildProximity);
                  }
                  else {
                      if (totalOffset+length<pragmaLocation_) {
                        int closeness = pragmaLocation_-(totalOffset+length);
                        if (closeness_==-1 || closeness<closeness_)   {  // get closest statement
                          oPragma_.setLocation(statement, PASTOMPPragma.NeighborProximity);
                          closeness_ = closeness;
                        }
                      }
                  }
                  // keep going to find tightest fit
              }

              // Check if this is the first node after the pragma - if so, could be our region
              if (totalOffset>pragmaLocation_) {
                if (searchType_!=LOCATION_ONLY) {
                  // With this we got to the next stmt:
                  if (searchType_==FOR_BLOCK && !(statement instanceof IASTForStatement))
                      return PROCESS_ABORT;  // error handled in determineRegion
                  // Set region information (ref. OpenMPArtifactView to see how used)
                  oPragma_.setRegionFilename(node.getContainingFilename()); 
                  oPragma_.setRegionLength(length);
                  oPragma_.setRegionOffset(localOffset);
                  oPragma_.setRegion(statement);
                  if (traceOn_)
                    System.out.println((searchType_==FOR_BLOCK ? "(for)" : "(region)") + "pragma at "+ pragmaLocation_+
                        " has statement at "+ localOffset);
                }
                return PROCESS_ABORT;
              }
            }
            return PROCESS_CONTINUE;
        }

    }

    
}