Attachment #212258 for bug #373597

View | Details | Raw Unified | Return to bug 373597
Collapse All | Expand All




/*******************************************************************************
 * Copyright (c) 2007, 2011, 2012 IBM Corporation, University of Illinois, and others.
 * 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
 *     Jeff Overbey (UIUC) - modified to use extension point
 *******************************************************************************/
package org.eclipse.ptp.pldt.common;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.index.IIndex;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.core.runtime.IStatus;

/**
 * Base class for implementations of {@link IArtifactAnalysis} that handle C and
 * C++.
 * <p>
 * This class contains the {@link #getAST(ITranslationUnit)} utility method,
 * which returns an {@link IASTTranslationUnit} for an {@link ITranslationUnit}.
 * 
 * @author Beth Tibbitts
 * @author Jeff Overbey
 * 
 * @since 6.0
 */
public abstract class ArtifactAnalysisBase implements IArtifactAnalysis {
	/**
	 * Get AST from index, not full tu
	 * 
	 * @param tu
	 *            translation unit from which to get the AST
	 * @return {@link IASTTranslationUnit} or <code>null</code>
	 */
	protected IASTTranslationUnit getAST(ITranslationUnit tu) {
		try {
			IIndex index = CCorePlugin.getIndexManager().getIndex(tu.getCProject());
			return tu.getAST(index, ITranslationUnit.AST_SKIP_ALL_HEADERS);
		} catch (Exception e) {
			CommonPlugin.log(IStatus.ERROR, "RunAnalyseHandlerBase.getAST(): Error getting AST (from index) for project " + tu.getCProject() + " " + e.getMessage()); //$NON-NLS-1$
			return null;
		}
	}
}




package org.eclipse.ptp.pldt.common;

import java.util.List;

import org.eclipse.cdt.core.model.ITranslationUnit;

/**
 * An artifact analysis for MPI, OpenMP, or OpenACC.
 * <p>
 * This interface is implemented by contributions to the following extension points:
 * <ul>
 * <li> org.eclipse.ptp.pldt.mpi.core.artifactAnalysis
 * <li> org.eclipse.ptp.pldt.openmp.core.artifactAnalysis
 * <li> org.eclipse.ptp.pldt.openacc.artifactAnalysis
 * </ul>
 * <p>
 * Implementations targeting C and C++ will typically subclass {@link ArtifactAnalysisBase}.
 * 
 * @since 6.0
 * 
 * @see ArtifactAnalysisBase
 */
public interface IArtifactAnalysis {
	ScanReturn runArtifactAnalysis(String languageID, ITranslationUnit tu, List<String> includes, boolean allowPrefixOnlyMatch);
}




/**********************************************************************
 * Copyright (c) 2005, 2011, 2012 IBM Corporation, University of Illinois, and others.
 * 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

 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Jeff Overbey (UIUC) - modified to use extension point
 *******************************************************************************/

package org.eclipse.ptp.pldt.common.actions;

import java.lang.reflect.InvocationTargetException;
import java.util.Iterator;
import java.util.List;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.index.IIndex;
import org.eclipse.cdt.core.model.ICContainer;
import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.core.model.ICProject;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.ptp.pldt.common.Artifact;
import org.eclipse.ptp.pldt.common.ArtifactMarkingVisitor;
import org.eclipse.ptp.pldt.common.CommonPlugin;
import org.eclipse.ptp.pldt.common.IArtifactAnalysis;
import org.eclipse.ptp.pldt.common.ScanReturn;
import org.eclipse.ptp.pldt.common.messages.Messages;
import org.eclipse.ptp.pldt.common.util.AnalysisUtil;

 * The analysis is done in the doArtifactAnalysis() method
 * 
 * @author Beth Tibbitts
 * @author Jeff Overbey
 * 
 *         IObjectActionDelegate enables popup menu selection <br>
 *         IWindowActionDelegate enables toolbar(or menu) selection

	public abstract ScanReturn doArtifactAnalysis(final ITranslationUnit tu, final List<String> includes);

	/**
	 * Runs an artifact analysis for the given file by searching the given extension point for an {@link IArtifactAnalysis} that matches its language ID.
	 * <p>
	 * This is a utility method generally invoked from {@link #doArtifactAnalysis(ITranslationUnit, List)}.
	 * <p>
	 * It is assumed that only one extension will be contributed per language ID.  If multiple extensions are found, it is unspecified which one will be run.
	 * 
	 * @param extensionPointID
	 * @param tu
	 * @param includes
	 * @param allowPrefixOnlyMatch
	 * @return {@link ScanReturn}
	 * 
	 * @since 6.0
	 */
	protected ScanReturn runArtifactAnalysisFromExtensionPoint(String extensionPointID, final ITranslationUnit tu, final List<String> includes, final boolean allowPrefixOnlyMatch) {
		try {
			final String languageID = tu.getLanguage().getId();
			for (IConfigurationElement config : Platform.getExtensionRegistry().getConfigurationElementsFor(extensionPointID)) {
				try {
					if (languageID.equals(config.getAttribute("languageID"))) {
						IArtifactAnalysis artifactAnalysis = (IArtifactAnalysis) config.createExecutableExtension("class"); //$NON-NLS-1$
						return artifactAnalysis.runArtifactAnalysis(languageID, tu, includes, allowPrefixOnlyMatch);
					}
				} catch (CoreException e) {
					CommonPlugin.log(e.getClass().getSimpleName() + ": " + e.getMessage());
				}
			}
		} catch (CoreException e) {
			e.printStackTrace();
			CommonPlugin.log(IStatus.ERROR, "RunAnalyseMPICommandHandler: Error setting up analysis for project " + tu.getCProject() + " error=" + e.getMessage()); //$NON-NLS-1$ //$NON-NLS-2$
		}
		return new ScanReturn();
	}

	/**
	 * Implemented for Handler; this replaces run() which is for actions.
	 */
	public Object execute(ExecutionEvent event) throws ExecutionException {

	}

	/**
	 * Get AST from index, not full tu
	 * 
	 * @param tu
	 *            translation unit from which to get the AST
	 * @return
	 */
	protected IASTTranslationUnit getAST(ITranslationUnit tu) {
		IIndex index;
		try {
			index = CCorePlugin.getIndexManager().getIndex(tu.getCProject());
			IASTTranslationUnit ast = tu.getAST(index, ITranslationUnit.AST_SKIP_ALL_HEADERS);
			// IASTTranslationUnit ast = tu.getAST(index, 0);
			if (traceOn) {
				System.out.println("    getAST(index,AST_SKIP_ALL_HEADERS)"); //$NON-NLS-1$
			}

			return ast;
		} catch (Exception e) {
			String msg = "RunAnalyseHandlerBase.getAST(): Error getting AST (from index) for project " + tu.getCProject() + " " + e.getMessage();//$NON-NLS-1$
			CommonPlugin.log(IStatus.ERROR, msg);
			return null;
		}

	}

	/**
	 * Get the include path. Subclass should override this method.
	 * 
	 * @return

Lines 7-13 bin.includes = plugin.xml,\ Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.mpi.core/build.properties (-1 / +2 lines)
7	.,\	7	.,\
8	templates/,\	8	templates/,\
9	plugin.properties,\	9	plugin.properties,\
10	about.html	10	about.html,\
		11	schema/
11	src.includes = html/,\	12	src.includes = html/,\
12	icons/,\	13	icons/,\
13	mpiref.xml,\	14	mpiref.xml,\




        
      </menuContribution>
   </extension>

   <!-- Code templates -->
   <extension point="org.eclipse.ui.editors.templates">
     <include file="templates/mpi_templates.xml" />
   </extension>

   <!-- Artifact analysis extension point -->
   <extension-point
      id="artifactAnalysis"
      name="MPI Artifact Analysis"
      schema="schema/artifactAnalysis.exsd"/>
   <!-- Artifact analyses for C and C++ -->
   <extension point="org.eclipse.ptp.pldt.mpi.core.artifactAnalysis">
      <artifactAnalysis
            languageID="org.eclipse.cdt.core.gcc"
            class="org.eclipse.ptp.pldt.mpi.core.analysis.CMPIArtifactAnalysis" />
      <artifactAnalysis
            languageID="org.eclipse.cdt.core.g++"
            class="org.eclipse.ptp.pldt.mpi.core.analysis.CMPIArtifactAnalysis" />
   </extension>

</plugin>




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.ptp.pldt.mpi.core" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.ptp.pldt.mpi.core" id="artifactAnalysis" name="MPI Artifact Analysis"/>
      </appInfo>
      <documentation>
         Allows plug-ins to contribute MPI artifact analyses.
      </documentation>
   </annotation>

   <element name="extension">
      <annotation>
         <appInfo>
            <meta.element />
         </appInfo>
      </annotation>
      <complexType>
         <sequence minOccurs="1" maxOccurs="unbounded">
            <element ref="artifactAnalysis"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="artifactAnalysis">
      <complexType>
         <attribute name="languageID" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute kind="identifier" basedOn="org.eclipse.cdt.core.language/language/@id"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="class" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn=":org.eclipse.ptp.pldt.common.IArtifactAnalysis"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appInfo>
         <meta.section type="since"/>
      </appInfo>
      <documentation>
         6.0
      </documentation>
   </annotation>





</schema>




/*******************************************************************************
 * Copyright (c) 2007, 2011, 2012 IBM Corporation, University of Illinois, and others.
 * 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

 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Jeff Overbey (UIUC) - modified to use extension point
 *******************************************************************************/

package org.eclipse.ptp.pldt.mpi.core.actions;

import java.lang.reflect.Method;
import java.util.List;

import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.gnu.c.GCCLanguage;
import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;
import org.eclipse.cdt.core.model.ILanguage;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.ptp.pldt.common.CommonPlugin;
import org.eclipse.ptp.pldt.common.ScanReturn;
import org.eclipse.ptp.pldt.common.actions.RunAnalyseHandlerBase;
import org.eclipse.ptp.pldt.common.util.ViewActivator;
import org.eclipse.ptp.pldt.mpi.core.MPIArtifactMarkingVisitor;
import org.eclipse.ptp.pldt.mpi.core.MpiPlugin;
import org.eclipse.ptp.pldt.mpi.core.analysis.MpiCASTVisitor;
import org.eclipse.ptp.pldt.mpi.core.analysis.MpiCPPASTVisitor;
import org.eclipse.ptp.pldt.mpi.internal.core.MpiIDs;

/**
 * @author Beth Tibbitts
 * @author Jeff Overbey
 */
public class RunAnalyseMPIcommandHandler extends RunAnalyseHandlerBase {
	/**
	 * ID for the extension point which allows plug-ins to contribute MPI artifact analyses based on language IDs.
	 */
	private static final String EXTENSION_POINT_ID = "org.eclipse.ptp.pldt.mpi.core.artifactAnalysis";

	/**
	 * Constructor for the "Run Analysis" action
	 */
	public RunAnalyseMPIcommandHandler() {

	 */
	@Override
	public ScanReturn doArtifactAnalysis(final ITranslationUnit tu, final List<String> includes) {
		final boolean allowPrefixOnlyMatch = MpiPlugin.getDefault().getPreferenceStore().getBoolean(MpiIDs.MPI_RECOGNIZE_APIS_BY_PREFIX_ALONE);
		return runArtifactAnalysisFromExtensionPoint(EXTENSION_POINT_ID, tu, includes, allowPrefixOnlyMatch);
		ILanguage lang;
		boolean allowPrefixOnlyMatch = MpiPlugin.getDefault().getPreferenceStore()
				.getBoolean(MpiIDs.MPI_RECOGNIZE_APIS_BY_PREFIX_ALONE);
		try {
			lang = tu.getLanguage();

			// long startTime = System.currentTimeMillis();
			IASTTranslationUnit atu = getAST(tu); // use index; was tu.getAST();

			// long endTime = System.currentTimeMillis();
			// System.out.println("RunAnalyseMPICommandHandler: time to build AST for "+tu+": "+(endTime-startTime)/1000.0+" sec");
			String languageID = lang.getId();
			if (languageID.equals(GCCLanguage.ID) || languageID.equals(GPPLanguage.ID)) {
				// null IASTTranslationUnit when we're doing C/C++ means we should quit.
				// but want to continue to see if this is a fortran file we are analyzing.
				if (atu == null) {// this is null for Fortran file during JUnit testing.
					System.out.println("RunAnalyseMPICommandHandler.doArtifactAnalysis(), atu is null (Fortran testing?)"); //$NON-NLS-1$
					return msr;
				}
			}
			if (languageID.equals(GCCLanguage.ID)) {// C
				atu.accept(new MpiCASTVisitor(includes, fileName, allowPrefixOnlyMatch, msr));
			} else if (languageID.equals(GPPLanguage.ID)) { // C++
				atu.accept(new MpiCPPASTVisitor(includes, fileName, allowPrefixOnlyMatch, msr));
			} else {
				// Attempt to handle Fortran
				// Instantiate using reflection to avoid static Photran dependencies
				try {
					Class<?> c = Class.forName("org.eclipse.ptp.pldt.mpi.fortran.actions.AnalyseMPIFortranHandler"); //$NON-NLS-1$
					Method method = c.getMethod("run", String.class, ITranslationUnit.class, String.class, ScanReturn.class); //$NON-NLS-1$
					method.invoke(c.newInstance(), languageID, tu, fileName, msr);
				} catch (Exception e) {
					System.err.println("RunAnalyseMPIcommandHandler.doArtifactAnalysis: Photran not installed"); //$NON-NLS-1$
				}
			}
		} catch (CoreException e) {
			e.printStackTrace();
			CommonPlugin
					.log(IStatus.ERROR,
							"RunAnalyseMPICommandHandler.getAST():Error setting up visitor for project " + tu.getCProject() + " error=" + e.getMessage()); //$NON-NLS-1$ //$NON-NLS-2$
		}
		return msr;
	}

	@Override




/*******************************************************************************
 * Copyright (c) 2007, 2011, 2012 IBM Corporation, University of Illinois, and others.
 * 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
 *     Jeff Overbey (UIUC) - modified to use extension point
 *******************************************************************************/
package org.eclipse.ptp.pldt.mpi.core.analysis;

import java.util.List;

import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.gnu.c.GCCLanguage;
import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.ptp.pldt.common.ArtifactAnalysisBase;
import org.eclipse.ptp.pldt.common.IArtifactAnalysis;
import org.eclipse.ptp.pldt.common.ScanReturn;

/**
 * MPI artifact analysis for C and C++.
 * <p>
 * Contributed to the <code>org.eclipse.ptp.pldt.mpi.core.artifactAnalysis</code> extension point.
 * 
 * @author Beth Tibbitts
 * @author Jeff Overbey
 */
public class CMPIArtifactAnalysis extends ArtifactAnalysisBase implements IArtifactAnalysis {
	public ScanReturn runArtifactAnalysis(String languageID, ITranslationUnit tu, List<String> includes, boolean allowPrefixOnlyMatch) {
		final ScanReturn msr = new ScanReturn();
		final String fileName = tu.getElementName();
		final IASTTranslationUnit atu = getAST(tu); // use index; was tu.getAST();
		if (atu != null) {
			if (languageID.equals(GCCLanguage.ID)) { // C
				atu.accept(new MpiCASTVisitor(includes, fileName, allowPrefixOnlyMatch, msr));
			} else if (languageID.equals(GPPLanguage.ID)) { // C++
				atu.accept(new MpiCPPASTVisitor(includes, fileName, allowPrefixOnlyMatch, msr));
			} else {
				throw new IllegalStateException("Unexpected language ID " + languageID);
			}
		}
		return msr;
	}
}

Lines 7-19 Bundle-ClassPath: . Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.mpi.fortran/META-INF/MANIFEST.MF (-4 / +8 lines)
7	Bundle-Activator: org.eclipse.ptp.pldt.mpi.fortran.Activator	7	Bundle-Activator: org.eclipse.ptp.pldt.mpi.fortran.Activator
8	Bundle-Vendor: %pluginProvider	8	Bundle-Vendor: %pluginProvider
9	Bundle-Localization: plugin	9	Bundle-Localization: plugin
10	Require-Bundle: org.eclipse.ui,	10	Require-Bundle: org.eclipse.core.runtime,
11	org.eclipse.core.runtime,
12	org.eclipse.core.resources,	11	org.eclipse.core.resources,
		12	org.eclipse.help,
		13	org.eclipse.ui,
		14	org.eclipse.ui.editors,
13	org.eclipse.cdt.core,	15	org.eclipse.cdt.core,
14	org.eclipse.cdt.ui,	16	org.eclipse.cdt.ui,
15	org.eclipse.ptp.pldt.common,
16	org.eclipse.photran.cdtinterface;bundle-version="7.0.0",	17	org.eclipse.photran.cdtinterface;bundle-version="7.0.0",
17	org.eclipse.photran.core.vpg;bundle-version="7.0.0"	18	org.eclipse.photran.core.vpg;bundle-version="7.0.0",
		19	org.eclipse.photran.ui;bundle-version="8.0.0",
		20	org.eclipse.ptp.pldt.common,
		21	org.eclipse.ptp.pldt.mpi.core
18	Bundle-ActivationPolicy: lazy	22	Bundle-ActivationPolicy: lazy
19	Bundle-RequiredExecutionEnvironment: J2SE-1.5	23	Bundle-RequiredExecutionEnvironment: J2SE-1.5

Lines 1-7 Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.mpi.fortran/build.properties (-1 / +2 lines)
1	bin.includes = META-INF/,\	1	bin.includes = META-INF/,\
2	.,\	2	.,\
3	plugin.properties,\	3	plugin.properties,\
4	about.html	4	about.html,\
		5	plugin.xml
5	jars.compile.order = .	6	jars.compile.order = .
6	source.. = src/	7	source.. = src/
7	output.. = bin/	8	output.. = bin/




<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.4"?>
<plugin>

   <!-- MPI artifact analysis for Fortran -->
   <extension point="org.eclipse.ptp.pldt.mpi.core.artifactAnalysis">
      <artifactAnalysis
            languageID="org.eclipse.photran.cdtinterface.fortran"
            class="org.eclipse.ptp.pldt.mpi.fortran.analysis.MPIFortranArtifactAnalysis" />
   </extension>

   <!-- Dynamic help for MPI in the Photran editor -->
   <extension
         point="org.eclipse.photran.ui.apiHelpProvider">
      <apiHelpProvider
            class="org.eclipse.ptp.pldt.mpi.fortran.editorHelp.MpiFortranHelpProvider">
      </apiHelpProvider>
   </extension>

</plugin>

Lines 13-18 package org.eclipse.ptp.pldt.mpi.fortran; Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.mpi.fortran/src/org/eclipse/ptp/pldt/mpi/fortran/Activator.java (-20 / +49 lines)
13		13
14	import org.eclipse.core.resources.IWorkspace;	14	import org.eclipse.core.resources.IWorkspace;
15	import org.eclipse.core.resources.ResourcesPlugin;	15	import org.eclipse.core.resources.ResourcesPlugin;
		16	import org.eclipse.core.runtime.IStatus;
		17	import org.eclipse.core.runtime.Status;
16	import org.eclipse.swt.widgets.Display;	18	import org.eclipse.swt.widgets.Display;
17	import org.eclipse.ui.plugin.AbstractUIPlugin;	19	import org.eclipse.ui.plugin.AbstractUIPlugin;
18	import org.osgi.framework.BundleContext;	20	import org.osgi.framework.BundleContext;
Lines 28-33 public class Activator extends AbstractUIPlugin { Link Here
28	private static final String PLUGIN_ID = "org.eclipse.ptp.pldt.mpi.fortran"; //$NON-NLS-1$	30	private static final String PLUGIN_ID = "org.eclipse.ptp.pldt.mpi.fortran"; //$NON-NLS-1$
29		31
30	/**	32	/**
		33	* Returns the shared instance.
		34	*/
		35	public static Activator getDefault() {
		36	return plugin;
		37	}
		38
		39	/**
		40	* Returns the workspace instance.
		41	*/
		42	public static IWorkspace getWorkspace() {
		43	return ResourcesPlugin.getWorkspace();
		44	}
		45
		46	/**
		47	* Returns the standard display to be used. The method first checks, if the
		48	* thread calling this method has an associated display. If so, this display
		49	* is returned. Otherwise the method returns the default display.
		50	*/
		51	public static Display getStandardDisplay() {
		52	Display display;
		53	display = Display.getCurrent();
		54	if (display == null) {
		55	display = Display.getDefault();
		56	}
		57	return display;
		58	}
		59
		60	public static String getPluginId() {
		61	return PLUGIN_ID;
		62	}
		63
		64	/**
31	* The constructor.	65	* The constructor.
32	*/	66	*/
33	public Activator() {	67	public Activator() {
Lines 53-86 public class Activator extends AbstractUIPlugin { Link Here
53	}	87	}
54		88
55	/**	89	/**
56	* Returns the shared instance.	90	* Create log entry from an IStatus
		91	*
		92	* @param status
57	*/	93	*/
58	public static Activator getDefault() {	94	public static void log(IStatus status) {
59	return plugin;	95	getDefault().getLog().log(status);
60	}	96	}
61		97
62	/**	98	/**
63	* Returns the workspace instance.	99	* Create log entry from a string
		100	*
		101	* @param msg
64	*/	102	*/
65	public static IWorkspace getWorkspace() {	103	public static void log(String msg) {
66	return ResourcesPlugin.getWorkspace();	104	log(new Status(IStatus.ERROR, getPluginId(), IStatus.ERROR, msg, null));
67	}	105	}
68		106
69	/**	107	/**
70	* Returns the standard display to be used. The method first checks, if the	108	* Create log entry from a Throwable
71	* thread calling this method has an associated display. If so, this display	109	*
72	* is returned. Otherwise the method returns the default display.	110	* @param e
73	*/	111	*/
74	public static Display getStandardDisplay() {	112	public static void log(Throwable e) {
75	Display display;	113	log(new Status(IStatus.ERROR, getPluginId(), IStatus.ERROR, e.getMessage(), e));
76	display = Display.getCurrent();
77	if (display == null) {
78	display = Display.getDefault();
79	}
80	return display;
81	}
82
83	public static String getPluginId() {
84	return PLUGIN_ID;
85	}	114	}
86	}	115	}

Lines 19-25 import org.eclipse.photran.internal.core.lexer.ASTLexerFactory; Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.mpi.fortran/src/org/eclipse/ptp/pldt/mpi/fortran/actions/AnalyseMPIFortranHandler.java (-2 / +2 lines)
19	import org.eclipse.photran.internal.core.parser.ASTExecutableProgramNode;	19	import org.eclipse.photran.internal.core.parser.ASTExecutableProgramNode;
20	import org.eclipse.photran.internal.core.parser.Parser;	20	import org.eclipse.photran.internal.core.parser.Parser;
21	import org.eclipse.ptp.pldt.common.ScanReturn;	21	import org.eclipse.ptp.pldt.common.ScanReturn;
22	import org.eclipse.ptp.pldt.mpi.fortran.analysis.MpiFortranASTVisitor;	22	import org.eclipse.ptp.pldt.mpi.fortran.analysis.MPIFortranASTVisitor;
23		23
24	/**	24	/**
25	* @since 4.0	25	* @since 4.0
Lines 34-40 public class AnalyseMPIFortranHandler { Link Here
34		34
35	try {	35	try {
36	ASTExecutableProgramNode ast = new Parser().parse(new ASTLexerFactory().createLexer(file));	36	ASTExecutableProgramNode ast = new Parser().parse(new ASTLexerFactory().createLexer(file));
37	ast.accept(new MpiFortranASTVisitor(fileName, msr));	37	ast.accept(new MPIFortranASTVisitor(fileName, msr));
38	} catch (Exception e) {	38	} catch (Exception e) {
39	e.printStackTrace(); // TODO	39	e.printStackTrace(); // TODO
40	}	40	}




/**********************************************************************
 * Copyright (c) 2005, 2010 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.mpi.fortran.analysis;

import org.eclipse.photran.internal.core.lexer.Token;
import org.eclipse.photran.internal.core.parser.ASTCallStmtNode;
import org.eclipse.photran.internal.core.parser.ASTNameNode;
import org.eclipse.photran.internal.core.parser.ASTVarOrFnRefNode;
import org.eclipse.photran.internal.core.parser.GenericASTVisitor;
import org.eclipse.ptp.pldt.common.Artifact;
import org.eclipse.ptp.pldt.common.ScanReturn;
import org.eclipse.ptp.pldt.common.util.SourceInfo;

/**
 * This dom-walker collects "artifacts" related to the specific domain <br>
 * (e.g. MPI, OpenMP, etc.). Currently these artifacts include function calls
 * and constants. It adds markers to the source file for C code, marking the
 * position of the artifacts found.
 * 
 * @author Beth Tibbitts
 * @since 4.0
 * 
 */
public class MPIFortranASTVisitor extends GenericASTVisitor {
	private static final String PREFIX = "MPI_"; //$NON-NLS-1$

	@SuppressWarnings("unused")
	private static final boolean traceOn = false;
	private final ScanReturn scanReturn;
	private final String fileName;

	@Override
	public void visitASTCallStmtNode(ASTCallStmtNode node) {
		Token subroutineName = node.getSubroutineName();
		addArtifact(subroutineName, Artifact.FUNCTION_CALL);
	}

	@Override
	public void visitASTVarOrFnRefNode(ASTVarOrFnRefNode node) {
		ASTNameNode nameNode = node.getName();
		if (nameNode != null) {
			Token varName = nameNode.getName();
			addArtifact(varName, Artifact.CONSTANT);
		}
	}

	private void addArtifact(Token subroutineName, int artifactType) {
		String callname = subroutineName.getText().toUpperCase();
		if (callname.startsWith(PREFIX)) {
			int start = subroutineName.getFileOffset();
			int end = subroutineName.getFileOffset() + subroutineName.getLength();
			SourceInfo si = new SourceInfo(subroutineName.getLine(), start, end, artifactType);
			scanReturn.addArtifact(new Artifact(fileName, subroutineName.getLine(), 1, callname, si));
		}
	}

	public MPIFortranASTVisitor(String fileName, ScanReturn scanReturn) {
		super();
		this.scanReturn = scanReturn;
		this.fileName = fileName;
	}

}




/*******************************************************************************
 * Copyright (c) 2012 University of Illinois at Urbana-Champaign and others.
 * 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:
 *     UIUC - Initial API and implementation
 *******************************************************************************/
package org.eclipse.ptp.pldt.mpi.fortran.analysis;

import java.util.List;

import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.ptp.pldt.common.IArtifactAnalysis;
import org.eclipse.ptp.pldt.common.ScanReturn;
import org.eclipse.ptp.pldt.mpi.fortran.actions.AnalyseMPIFortranHandler;

/**
 * MPI artifact analysis for Fortran.
 * <p>
 * Contributed to the <code>org.eclipse.ptp.pldt.mpi.core.artifactAnalysis</code> extension point.
 * 
 * @author Jeff Overbey
 */
public class MPIFortranArtifactAnalysis implements IArtifactAnalysis {
	public ScanReturn runArtifactAnalysis(String languageID, ITranslationUnit tu, List<String> includes, boolean allowPrefixOnlyMatch) {
		final ScanReturn msr = new ScanReturn();
		new AnalyseMPIFortranHandler().run(languageID, tu, tu.getElementName(), msr);
		return msr;
	}
}




/**********************************************************************
 * Copyright (c) 2005, 2010 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.mpi.fortran.analysis;

import org.eclipse.photran.internal.core.lexer.Token;
import org.eclipse.photran.internal.core.parser.ASTCallStmtNode;
import org.eclipse.photran.internal.core.parser.ASTNameNode;
import org.eclipse.photran.internal.core.parser.ASTVarOrFnRefNode;
import org.eclipse.photran.internal.core.parser.GenericASTVisitor;
import org.eclipse.ptp.pldt.common.Artifact;
import org.eclipse.ptp.pldt.common.ScanReturn;
import org.eclipse.ptp.pldt.common.util.SourceInfo;

/**
 * This dom-walker collects "artifacts" related to the specific domain <br>
 * (e.g. MPI, OpenMP, etc.). Currently these artifacts include function calls
 * and constants. It adds markers to the source file for C code, marking the
 * position of the artifacts found.
 * 
 * @author Beth Tibbitts
 * @since 4.0
 * 
 */
public class MpiFortranASTVisitor extends GenericASTVisitor {
	private static final String PREFIX = "MPI_"; //$NON-NLS-1$

	@SuppressWarnings("unused")
	private static final boolean traceOn = false;
	private final ScanReturn scanReturn;
	private final String fileName;

	@Override
	public void visitASTCallStmtNode(ASTCallStmtNode node) {
		Token subroutineName = node.getSubroutineName();
		addArtifact(subroutineName, Artifact.FUNCTION_CALL);
	}

	@Override
	public void visitASTVarOrFnRefNode(ASTVarOrFnRefNode node) {
		ASTNameNode nameNode = node.getName();
		if (nameNode != null) {
			Token varName = nameNode.getName();
			addArtifact(varName, Artifact.CONSTANT);
		}
	}

	private void addArtifact(Token subroutineName, int artifactType) {
		String callname = subroutineName.getText().toUpperCase();
		if (callname.startsWith(PREFIX)) {
			int start = subroutineName.getFileOffset();
			int end = subroutineName.getFileOffset() + subroutineName.getLength();
			SourceInfo si = new SourceInfo(subroutineName.getLine(), start, end, artifactType);
			scanReturn.addArtifact(new Artifact(fileName, subroutineName.getLine(), 1, callname, si));
		}
	}

	public MpiFortranASTVisitor(String fileName, ScanReturn scanReturn) {
		super();
		this.scanReturn = scanReturn;
		this.fileName = fileName;
	}

}




/**********************************************************************
 * Copyright (c) 2005, 2011 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.mpi.fortran.editorHelp;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.help.IHelpResource;
import org.eclipse.photran.ui.IFortranAPIHelpProvider;
import org.eclipse.ptp.pldt.mpi.core.MpiPlugin;
import org.eclipse.ptp.pldt.mpi.fortran.Activator;
import org.eclipse.ui.texteditor.ITextEditor;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * Help book for Fortran MPI functions
 * 
 * @author Beth Tibbitts
 * @author Jeff Overbey
 */
public class MpiFortranHelpProvider implements IFortranAPIHelpProvider {
	private final Map<String, String> fNameToCname;

	/**
	 * builds the list of function summaries by parsing an XML file
	 */
	public MpiFortranHelpProvider() {
		Map<String, String> fNameToCname;
		URL fileURL = FileLocator.find(Platform.getBundle(MpiPlugin.getPluginId()), new Path("mpiref.xml"), null); //$NON-NLS-1$
		try {
			fNameToCname = parseDOM(fileURL.openStream());
		} catch (IOException e) {
			Activator.log(e);
			fNameToCname = Collections.<String, String>emptyMap();
		}
		this.fNameToCname = fNameToCname;
	}

	public static Map<String, String> parseDOM(InputStream xmlIn) {
		final Map<String, String> fNameToCname = new HashMap<String, String>();
		if (xmlIn != null)
		{
			try {
				DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
				Document document = builder.parse(xmlIn);
				NodeList functionList = document.getElementsByTagName("function");//$NON-NLS-1$
				for (int i = 0; i < functionList.getLength(); i++) {
					Node func = functionList.item(i);
					NodeList child = func.getChildNodes();
					String fname = null;
					String cname = null;
					// String desc = null;
					for (int j = 0; j < child.getLength(); j++) {
						Node sub = child.item(j);
						if (sub.getNodeName().equals("cname")) {
							cname = sub.getTextContent(); // java 5
						//} else if (sub.getNodeName().equals("description")) {//$NON-NLS-1$
							// desc = sub.getTextContent(); // java 5
						} else if (sub.getNodeName().equals("fname")) {//$NON-NLS-1$
							fname = sub.getTextContent(); // java 5
						}
					}
					if (fname != null && cname != null) {
						fNameToCname.put(fname.toUpperCase(), cname);
					}
				}
			} catch (Exception e) {
				Activator.log(e);
			}
		}
		return fNameToCname;
	}

	public IHelpResource[] getHelpResources(ITextEditor fortranEditor, String name, String precedingText) {
		final String fname = name.toUpperCase();
		if (fNameToCname.containsKey(fname)) {
			return new IHelpResource[] { new IHelpResource() {
				public String getHref() {
					return String.format("/%s/html/%s.html", MpiPlugin.getPluginId(), fNameToCname.get(fname));
				}
				public String getLabel() {
					return fname;
				}
			} };
		}
		return null;
	}
}

Lines 15-20 Require-Bundle: org.eclipse.core.runtime, Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.openacc.fortran/META-INF/MANIFEST.MF (+3 lines)
15	org.eclipse.cdt.ui,	15	org.eclipse.cdt.ui,
16	org.eclipse.ptp.pldt.common,	16	org.eclipse.ptp.pldt.common,
17	org.eclipse.ptp.pldt.openacc,	17	org.eclipse.ptp.pldt.openacc,
		18	org.eclipse.photran.core,
		19	org.eclipse.photran.core.vpg,
		20	org.eclipse.photran.cdtinterface,
18	org.eclipse.photran.ui;bundle-version="8.0.0"	21	org.eclipse.photran.ui;bundle-version="8.0.0"
19	Bundle-ActivationPolicy: lazy	22	Bundle-ActivationPolicy: lazy
20	Bundle-ClassPath: .	23	Bundle-ClassPath: .

Lines 2-7 Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.openacc.fortran/plugin.xml (+7 lines)
2	<?eclipse version="3.0"?>	2	<?eclipse version="3.0"?>
3	<plugin>	3	<plugin>
4		4
		5	<!-- OpenACC artifact analysis for Fortran -->
		6	<extension point="org.eclipse.ptp.pldt.openacc.artifactAnalysis">
		7	<artifactAnalysis
		8	languageID="org.eclipse.photran.cdtinterface.fortran"
		9	class="org.eclipse.ptp.pldt.openacc.internal.fortran.actions.OpenACCFortranArtifactAnalysis" />
		10	</extension>
		11
5	<!-- OpenACC API help for Fortran -->	12	<!-- OpenACC API help for Fortran -->
6	<extension	13	<extension
7	point="org.eclipse.photran.ui.apiHelpProvider">	14	point="org.eclipse.photran.ui.apiHelpProvider">




/**********************************************************************
 * Copyright (c) 2005, 2010 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.openacc.internal.fortran.actions;

import org.eclipse.photran.internal.core.lexer.Token;
import org.eclipse.photran.internal.core.parser.ASTCallStmtNode;
import org.eclipse.photran.internal.core.parser.ASTNameNode;
import org.eclipse.photran.internal.core.parser.ASTVarOrFnRefNode;
import org.eclipse.photran.internal.core.parser.GenericASTVisitor;
import org.eclipse.ptp.pldt.common.Artifact;
import org.eclipse.ptp.pldt.common.ScanReturn;
import org.eclipse.ptp.pldt.common.util.SourceInfo;

/**
 * This dom-walker collects "artifacts" related to the specific domain <br>
 * (e.g. MPI, OpenMP, etc.). Currently these artifacts include function calls
 * and constants. It adds markers to the source file for C code, marking the
 * position of the artifacts found.
 * 
 * @author Beth Tibbitts
 * @since 4.0
 * 
 */
public class OpenACCFortranASTVisitor extends GenericASTVisitor {
	private static final String PREFIX = "ACC_"; //$NON-NLS-1$

	@SuppressWarnings("unused")
	private static final boolean traceOn = false;
	private final ScanReturn scanReturn;
	private final String fileName;

	@Override
	public void visitToken(Token node) {
		/*
		 * In Fortran, OpenACC directives are comments (e.g., !$acc parallel).
		 * Photran attaches comments to the following token. Since they appear
		 * before several types of statements (including END statements), it's
		 * easiest to just iterate through all the tokens in the AST and collect
		 * the preceding OpenMP directives.
		 */
		for (Token accDirective : node.getOpenACCComments()) {
			addArtifact(accDirective, Artifact.PRAGMA);
		}
	}

	@Override
	public void visitASTCallStmtNode(ASTCallStmtNode node) {
		Token subroutineName = node.getSubroutineName();
		addArtifact(subroutineName, Artifact.FUNCTION_CALL);
	}

	@Override
	public void visitASTVarOrFnRefNode(ASTVarOrFnRefNode node) {
		ASTNameNode nameNode = node.getName();
		if (nameNode != null) {
			Token varName = nameNode.getName();
			addArtifact(varName, Artifact.CONSTANT);
		}
	}

	private void addArtifact(Token subroutineName, int artifactType) {
		String callname = subroutineName.getText().toUpperCase();
		if (artifactType == Artifact.PRAGMA || callname.startsWith(PREFIX)) {
			int start = subroutineName.getFileOffset();
			int end = subroutineName.getFileOffset() + subroutineName.getLength();
			SourceInfo si = new SourceInfo(subroutineName.getLine(), start, end, artifactType);
			scanReturn.addArtifact(new Artifact(fileName, subroutineName.getLine(), 1, callname, si));
		}
	}

	public OpenACCFortranASTVisitor(String fileName, ScanReturn scanReturn) {
		super();
		this.scanReturn = scanReturn;
		this.fileName = fileName;
	}

}




/*******************************************************************************
 * Copyright (c) 2012 University of Illinois at Urbana-Champaign and others.
 * 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:
 *     UIUC - Initial API and implementation
 *******************************************************************************/
package org.eclipse.ptp.pldt.openacc.internal.fortran.actions;

import java.util.List;

import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.photran.internal.cdtinterface.core.FortranLanguage;
import org.eclipse.photran.internal.core.lexer.ASTLexerFactory;
import org.eclipse.photran.internal.core.parser.ASTExecutableProgramNode;
import org.eclipse.photran.internal.core.parser.Parser;
import org.eclipse.ptp.pldt.common.IArtifactAnalysis;
import org.eclipse.ptp.pldt.common.ScanReturn;

/**
 * OpenACC artifact analysis for Fortran.
 * <p>
 * Contributed to the <code>org.eclipse.ptp.pldt.mpi.core.artifactAnalysis</code> extension point.
 * 
 * @author Jeff Overbey
 */
public class OpenACCFortranArtifactAnalysis implements IArtifactAnalysis {
	@Override
	public ScanReturn runArtifactAnalysis(String languageID, ITranslationUnit tu, List<String> includes, boolean allowPrefixOnlyMatch) {
		final ScanReturn msr = new ScanReturn();
		final String fileName = tu.getElementName();
		if (languageID.equals(FortranLanguage.LANGUAGE_ID)) {
			IResource res = tu.getUnderlyingResource();
			if (!(res instanceof IFile))
				throw new IllegalStateException();
			IFile file = (IFile) res;

			try {
				ASTExecutableProgramNode ast = new Parser().parse(new ASTLexerFactory().createLexer(file));
				ast.accept(new OpenACCFortranASTVisitor(fileName, msr));
			} catch (Exception e) {
				e.printStackTrace(); // TODO
			}
		}
		return msr;
	}
}




	/** Plug-in ID for the main (non-Fortran) OpenACC plug-in, which contains HTML documentation. */
	private static final String OPENACC_PLUGIN_ID = "org.eclipse.ptp.pldt.openacc"; //$NON-NLS-1$

	/** Pattern matching the start of an OpenACC directive */
	private static final Pattern OPENACC_DIRECTIVE_PREFIX_PATTERN = Pattern
			.compile("(^[Cc*]|[ \\t]*!)\\$acc([ \\t]+end)?([ \\t]+parallel)?[ \\t]*"); //$NON-NLS-1$

	/** Format string for an OpenACC directive.  %s is replaced with a directive name. */
	private static final String OPENACC_DIRECTIVE_REGEX_FORMAT =
			"(^[Cc*]|[ \\t]*!)\\$acc([ \\t]+end)?([ \\t]+parallel)?[ \\t]+%s.*"; //$NON-NLS-1$

	private final Set<String> procedures = new HashSet<String>(32);
	private final Set<String> directives = new HashSet<String>(32);

	/** Constructor */
	public OpenACCFortranHelpProvider() {
		// Section numbers from the OpenACC specification: "The OpenACC Application Programming Interface, Version 1.0"
		procedures.add("acc_get_num_devices"); // Section 3.2.1 //$NON-NLS-1$
		procedures.add("acc_set_device_type"); // 3.2.2 //$NON-NLS-1$
		procedures.add("acc_get_device_type"); // 3.2.3 //$NON-NLS-1$
		procedures.add("acc_set_device_num"); // 3.2.4 //$NON-NLS-1$

		final String fname = apiName.toLowerCase();
		if (procedures.contains(fname)) {
			return getHelpResourceForFilename(fname);
		} else if (OPENACC_DIRECTIVE_PREFIX_PATTERN.matcher(precedingText).find()) {
			if (directives.contains(fname)) {
				return getHelpResourceForFilename("pragma_acc_" + fname); //$NON-NLS-1$
			} else {
				for (String directive : directives) {
					if (precedingText.matches(String.format(OPENACC_DIRECTIVE_REGEX_FORMAT, directive))) {
						return getHelpResourceForFilename("pragma_acc_" + directive); //$NON-NLS-1$
					}
				}
			}
		}
		return null;
	}




<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<templates>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.cache"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC cache directive" enabled="true"
		name="!$acc cache">!$$acc cache (${cursor})</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.data"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC data directive" enabled="true"
		name="!$acc data">!$$acc data${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.endd_ata"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC end data directive" enabled="true"
		name="!$acc end data">!$$acc end data${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.declare"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC declare directive" enabled="true"
		name="!$acc declare">!$$acc declare ${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.host_data"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC host_data directive" enabled="true"
		name="!$acc host_data">!$$acc host_data${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_host_data"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC end host_data directive" enabled="true"
		name="!$acc end host_data">!$$acc end host_data${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.kernels"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC kernels directive" enabled="true"
		name="!$acc kernels">!$$acc kernels${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_kernels"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC end kernels directive" enabled="true"
		name="!$acc end kernels">!$$acc end kernels${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.kernels_loop"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC kernels loop directive" enabled="true"
		name="!$acc kernels loop">!$$acc kernels loop${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_kernels_loop"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC end kernels loop directive" enabled="true"
		name="!$acc end kernels loop">!$$acc end kernels loop${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.loop"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC loop directive" enabled="true"
		name="!$acc loop">!$$acc loop${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_loop"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC end loop directive" enabled="true"
		name="!$acc end loop">!$$acc end loop${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.parallel"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC parallel directive" enabled="true"
		name="!$acc parallel">!$$acc parallel${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_parallel"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC end parallel directive" enabled="true"
		name="!$acc end parallel">!$$acc end parallel${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.parallel_loop"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC parallel loop directive" enabled="true"
		name="!$acc parallel loop">!$$acc parallel loop${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_parallel_loop"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC end parallel loop directive" enabled="true"
		name="!$acc end parallel loop">!$$acc end parallel loop${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.update"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC update directive" enabled="true"
		name="!$acc update">!$$acc update ${cursor}</template>
	<template id="org.eclipse.ptp.pldt.openacc.fortran.wait"
		autoinsert="true" context="org.eclipse.photran.ui.template.context"
		deleted="false" description="OpenACC wait directive" enabled="true"
		name="!$acc wait">!$$acc wait${cursor}</template>
</templates>

Lines 11-15 bin.includes = META-INF/,\ Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.openacc/build.properties (-1 / +2 lines)
11	about.mappings,\	11	about.mappings,\
12	about.properties,\	12	about.properties,\
13	ptp_logo_icon32.png,\	13	ptp_logo_icon32.png,\
14	templates/	14	templates/,\
		15	schema/
15	jre.compilation.profile = JavaSE-1.6	16	jre.compilation.profile = JavaSE-1.6




         </initializer>
      </extension>

   <!-- OpenACC artifact analysis extension point -->
   <extension-point
      id="artifactAnalysis"
      name="OpenACC Artifact Analysis"
      schema="schema/artifactAnalysis.exsd"/>
   <!-- OpenACC atifact analyses for C and C++ -->
   <extension point="org.eclipse.ptp.pldt.openacc.artifactAnalysis">
      <artifactAnalysis
            languageID="org.eclipse.cdt.core.gcc"
            class="org.eclipse.ptp.pldt.openacc.internal.actions.OpenACCCArtifactAnalysis" />
      <artifactAnalysis
            languageID="org.eclipse.cdt.core.g++"
            class="org.eclipse.ptp.pldt.openacc.internal.actions.OpenACCCArtifactAnalysis" />
   </extension>

   <!-- OpenACC C help book -->
   <extension
         point="org.eclipse.cdt.ui.CHelpProvider">




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.ptp.pldt.mpi.core" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.ptp.pldt.mpi.core" id="artifactAnalysis" name="OpenACC Artifact Analysis"/>
      </appInfo>
      <documentation>
         Allows plug-ins to contribute OpenACC artifact analyses.
      </documentation>
   </annotation>

   <element name="extension">
      <annotation>
         <appInfo>
            <meta.element />
         </appInfo>
      </annotation>
      <complexType>
         <sequence minOccurs="1" maxOccurs="unbounded">
            <element ref="artifactAnalysis"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="artifactAnalysis">
      <complexType>
         <attribute name="languageID" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute kind="identifier" basedOn="org.eclipse.cdt.core.language/language/@id"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="class" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn=":org.eclipse.ptp.pldt.common.IArtifactAnalysis"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appInfo>
         <meta.section type="since"/>
      </appInfo>
      <documentation>
         6.0
      </documentation>
   </annotation>





</schema>




/*******************************************************************************
 * Copyright (c) 2007, 2011, 2012 IBM Corporation, University of Illinois, and others.
 * 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
 *     Jeff Overbey (UIUC) - modified to use extension point
 *******************************************************************************/
package org.eclipse.ptp.pldt.openacc.internal.actions;

import java.util.List;
import java.util.regex.Pattern;

import org.eclipse.cdt.core.dom.ast.IASTFileLocation;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorPragmaStatement;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorStatement;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.ptp.pldt.common.Artifact;
import org.eclipse.ptp.pldt.common.ArtifactAnalysisBase;
import org.eclipse.ptp.pldt.common.IArtifactAnalysis;
import org.eclipse.ptp.pldt.common.ScanReturn;
import org.eclipse.ptp.pldt.common.util.SourceInfo;
import org.eclipse.ptp.pldt.openacc.internal.messages.Messages;

/**
 * OpenACC artifact analysis for C and C++.
 * <p>
 * Contributed to the <code>org.eclipse.ptp.pldt.openacc.artifactAnalysis</code> extension point.
 * 
 * @author Beth Tibbitts
 * @author Jeff Overbey
 */
public class OpenACCCArtifactAnalysis extends ArtifactAnalysisBase implements IArtifactAnalysis {

	private static final Pattern ACC_PRAGMA_PATTERN = Pattern
			.compile("acc[ \t]*(parallel|kernels|data|host_data|loop|cache|declare|update|wait).*"); //$NON-NLS-1$

	@Override
	public ScanReturn runArtifactAnalysis(String languageID, ITranslationUnit tu, List<String> includes, boolean allowPrefixOnlyMatch) {
		final ScanReturn msr = new ScanReturn();
		final IASTTranslationUnit atu = getAST(tu); // use index; was tu.getAST();
		if (atu != null) {
			findOpenACCFunctionCalls(includes, msr, tu.getElementName(), atu, allowPrefixOnlyMatch);
			findOpenACCPragmas(atu, msr);
		}
		return msr;
	}

	private void findOpenACCFunctionCalls(final List<String> includes,
			final ScanReturn msr, final String fileName,
			final IASTTranslationUnit atu, boolean allowPrefixOnlyMatch) {
		atu.accept(new OpenACCCASTVisitor(includes, fileName, allowPrefixOnlyMatch, msr));
	}

	private void findOpenACCPragmas(final IASTTranslationUnit atu, final ScanReturn msr) {
		for (final IASTPreprocessorStatement preprocStmt : atu.getAllPreprocessorStatements()) {
			if (preprocStmt instanceof IASTPreprocessorPragmaStatement) {
				final String pragmaText = String.valueOf(((IASTPreprocessorPragmaStatement) preprocStmt).getMessage()).trim();
				if (preprocStmt.isPartOfTranslationUnitFile() && ACC_PRAGMA_PATTERN.matcher(pragmaText).matches()) {
					final IASTFileLocation astFileLocation = preprocStmt.getFileLocation();
					final SourceInfo sourceInfo = new SourceInfo();
					sourceInfo.setStartingLine(astFileLocation.getStartingLineNumber());
					sourceInfo.setStart(astFileLocation.getNodeOffset());
					sourceInfo.setEnd(astFileLocation.getNodeOffset() + astFileLocation.getNodeLength());
					sourceInfo.setConstructType(Artifact.PRAGMA);

					msr.addArtifact(
							new Artifact(
									preprocStmt.getContainingFilename(),
									astFileLocation.getStartingLineNumber(),
									1,
									"#pragma " + pragmaText, //$NON-NLS-1$
									Messages.RunAnalyseOpenACCcommandHandler_OpenACC_directive,
									sourceInfo,
									null));
				}
			}
		}
	}
}




/**********************************************************************
 * Copyright (c) 2007, 2011, 2012 IBM Corporation and University of Illinois.
 * 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

 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Jeff Overbey - adaptation to OpenACC, modified to use extension point
 *******************************************************************************/
package org.eclipse.ptp.pldt.openacc.internal.actions;

import java.util.List;
import java.util.regex.Pattern;

import org.eclipse.cdt.core.dom.ast.IASTFileLocation;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorPragmaStatement;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorStatement;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.gnu.c.GCCLanguage;
import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.ptp.pldt.common.Artifact;
import org.eclipse.ptp.pldt.common.ArtifactMarkingVisitor;
import org.eclipse.ptp.pldt.common.ScanReturn;
import org.eclipse.ptp.pldt.common.actions.RunAnalyseHandlerBase;
import org.eclipse.ptp.pldt.common.util.SourceInfo;
import org.eclipse.ptp.pldt.common.util.ViewActivator;
import org.eclipse.ptp.pldt.openacc.internal.Activator;
import org.eclipse.ptp.pldt.openacc.internal.IDs;
import org.eclipse.ptp.pldt.openacc.internal.messages.Messages;

/**
 * Handler for the &quot;Show OpenACC Artifacts&quot; command.

 * @author Jeff Overbey
 */
public class RunAnalyseOpenACCcommandHandler extends RunAnalyseHandlerBase {
	/**
	 * ID for the OpenACC Artifacts view, contributed in plugin.xml.
	 */
	private static final String VIEW_ID = "org.eclipse.ptp.pldt.openacc.views.OpenACCArtifactView"; //$NON-NLS-1$

	/**
	 * ID for the extension point which allows plug-ins to contribute OpenMP artifact analyses based on language IDs.
	 */
	private static final String EXTENSION_POINT_ID = "org.eclipse.ptp.pldt.openacc.artifactAnalysis"; //$NON-NLS-1$

	/**
	 * Constructor.  Invoked dynamically due to class reference in plugin.xml.

	 */
	@Override
	public ScanReturn doArtifactAnalysis(final ITranslationUnit tu, final List<String> includes) {
		final boolean allowPrefixOnlyMatch = Activator.getDefault().getPreferenceStore().getBoolean(IDs.PREF_RECOGNIZE_APIS_BY_PREFIX_ALONE);
		return runArtifactAnalysisFromExtensionPoint(EXTENSION_POINT_ID, tu, includes, allowPrefixOnlyMatch);
				.getBoolean(IDs.PREF_RECOGNIZE_APIS_BY_PREFIX_ALONE);
		if (traceOn)
		{
			System.out.println("RALCH:OpenACC allowPrefixOnlyMatch=" + allowPrefixOnlyMatch); //$NON-NLS-1$
		}
		try {
			final IASTTranslationUnit atu = tu.getAST();
			final String languageID = tu.getLanguage().getId();
			if (languageID.equals(GCCLanguage.ID) || languageID.equals(GPPLanguage.ID)) {
				findOpenACCFunctionCalls(includes, msr, tu.getElementName(), atu, allowPrefixOnlyMatch);
				findOpenACCPragmas(atu, msr);
			}
		} catch (final CoreException e) {
			Activator.log(e);
		}
		return msr;
	}

	private void findOpenACCFunctionCalls(final List<String> includes,
			final ScanReturn msr, final String fileName,
			final IASTTranslationUnit atu, boolean allowPrefixOnlyMatch) {
		atu.accept(new OpenACCCASTVisitor(includes, fileName, allowPrefixOnlyMatch, msr));
	}

	private void findOpenACCPragmas(final IASTTranslationUnit atu, final ScanReturn msr) {
		for (final IASTPreprocessorStatement preprocStmt : atu.getAllPreprocessorStatements()) {
			if (preprocStmt instanceof IASTPreprocessorPragmaStatement) {
				final String pragmaText = String.valueOf(((IASTPreprocessorPragmaStatement) preprocStmt).getMessage()).trim();
				if (preprocStmt.isPartOfTranslationUnitFile() && ACC_PRAGMA_PATTERN.matcher(pragmaText).matches()) {
					final IASTFileLocation astFileLocation = preprocStmt.getFileLocation();
					final SourceInfo sourceInfo = new SourceInfo();
					sourceInfo.setStartingLine(astFileLocation.getStartingLineNumber());
					sourceInfo.setStart(astFileLocation.getNodeOffset());
					sourceInfo.setEnd(astFileLocation.getNodeOffset() + astFileLocation.getNodeLength());
					sourceInfo.setConstructType(Artifact.PRAGMA);

					msr.addArtifact(
							new Artifact(
									preprocStmt.getContainingFilename(),
									astFileLocation.getStartingLineNumber(),
									1,
									"#pragma " + pragmaText, //$NON-NLS-1$
									Messages.RunAnalyseOpenACCcommandHandler_OpenACC_directive,
									sourceInfo,
									null));
				}
			}
		}
	}

	@Override

Lines 7-11 bin.includes = META-INF/,\ Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.openmp.core/build.properties (-1 / +2 lines)
7	samples/,\	7	samples/,\
8	plugin.properties,\	8	plugin.properties,\
9	html/,\	9	html/,\
10	about.html	10	about.html,\
		11	schema/
11	bin.excludes = icons/.cvsignore	12	bin.excludes = icons/.cvsignore




               class="org.eclipse.ptp.pldt.openmp.core.prefs.OpenMPPreferenceInitializer">
         </initializer>
      </extension>

   <!-- Artifact analysis extension point -->
   <extension-point
      id="artifactAnalysis"
      name="OpenMP Artifact Analysis"
      schema="schema/artifactAnalysis.exsd"/>
   <!-- Artifact analysis for C -->
   <extension point="org.eclipse.ptp.pldt.openmp.core.artifactAnalysis">
      <artifactAnalysis
            languageID="org.eclipse.cdt.core.gcc"
            class="org.eclipse.ptp.pldt.openmp.core.analysis.OpenMPCArtifactAnalysis" />
      <artifactAnalysis
            languageID="org.eclipse.cdt.core.g++"
            class="org.eclipse.ptp.pldt.openmp.core.analysis.OpenMPCArtifactAnalysis" />
   </extension>

</plugin>




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.ptp.pldt.mpi.core" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.ptp.pldt.mpi.core" id="artifactAnalysis" name="OpenMP Artifact Analysis"/>
      </appInfo>
      <documentation>
         Allows plug-ins to contribute OpenMP artifact analyses.
      </documentation>
   </annotation>

   <element name="extension">
      <annotation>
         <appInfo>
            <meta.element />
         </appInfo>
      </annotation>
      <complexType>
         <sequence minOccurs="1" maxOccurs="unbounded">
            <element ref="artifactAnalysis"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="artifactAnalysis">
      <complexType>
         <attribute name="languageID" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute kind="identifier" basedOn="org.eclipse.cdt.core.language/language/@id"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="class" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn=":org.eclipse.ptp.pldt.common.IArtifactAnalysis"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appInfo>
         <meta.section type="since"/>
      </appInfo>
      <documentation>
         6.0
      </documentation>
   </annotation>





</schema>




/*******************************************************************************
 * Copyright (c) 2007, 2011, 2012 IBM Corporation, University of Illinois, and others.
 * 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

 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Jeff Overbey (UIUC) - modified to use extension point
 *******************************************************************************/

package org.eclipse.ptp.pldt.openmp.core.actions;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.cdt.core.dom.ast.IASTFileLocation;
import org.eclipse.cdt.core.dom.ast.IASTNodeLocation;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.gnu.c.GCCLanguage;
import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;
import org.eclipse.cdt.core.model.ILanguage;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.ptp.pldt.common.Artifact;
import org.eclipse.ptp.pldt.common.ScanReturn;
import org.eclipse.ptp.pldt.common.actions.RunAnalyseHandlerBase;
import org.eclipse.ptp.pldt.common.util.SourceInfo;
import org.eclipse.ptp.pldt.common.util.ViewActivator;
import org.eclipse.ptp.pldt.openmp.analysis.OpenMPAnalysisManager;
import org.eclipse.ptp.pldt.openmp.analysis.OpenMPError;
import org.eclipse.ptp.pldt.openmp.analysis.OpenMPErrorManager;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTNode;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTPragma;
import org.eclipse.ptp.pldt.openmp.core.OpenMPArtifactMarkingVisitor;
import org.eclipse.ptp.pldt.openmp.core.OpenMPPlugin;
import org.eclipse.ptp.pldt.openmp.core.OpenMPScanReturn;
import org.eclipse.ptp.pldt.openmp.core.analysis.OpenMPCASTVisitor;
import org.eclipse.ptp.pldt.openmp.core.internal.OpenMPIDs;
import org.eclipse.ptp.pldt.openmp.core.messages.Messages;
import org.eclipse.ptp.pldt.openmp.ui.pv.internal.IDs;
import org.eclipse.ptp.pldt.openmp.ui.pv.views.ProblemMarkerAttrIds;
import org.eclipse.ui.texteditor.MarkerUtilities;

 * 
 */
public class RunAnalyseOpenMPcommandHandler extends RunAnalyseHandlerBase {
	/**
	 * ID for the extension point which allows plug-ins to contribute OpenMP artifact analyses based on language IDs.
	 */
	private static final String EXTENSION_POINT_ID = "org.eclipse.ptp.pldt.openmp.core.artifactAnalysis";

	private static final boolean traceOn = false;

	/**

	 */
	@Override
	public ScanReturn doArtifactAnalysis(final ITranslationUnit tu, final List<String> includes) {
		boolean allowPrefixOnlyMatch = OpenMPPlugin.getDefault().getPreferenceStore().getBoolean(OpenMPIDs.OPENMP_RECOGNIZE_APIS_BY_PREFIX_ALONE);
		return runArtifactAnalysisFromExtensionPoint(EXTENSION_POINT_ID, tu, includes, allowPrefixOnlyMatch);
		IASTTranslationUnit atu = null;
		ILanguage lang;
		boolean allowPrefixOnlyMatch = OpenMPPlugin.getDefault().getPreferenceStore()
				.getBoolean(OpenMPIDs.OPENMP_RECOGNIZE_APIS_BY_PREFIX_ALONE);
		try {
			lang = tu.getLanguage();

			// atu = tu.getAST();
			atu = getAST(tu); // use index; was tu.getAST(); otherwise fortran fails?
			String languageID = lang.getId();

			if (languageID.equals(GCCLanguage.ID) || languageID.equals(GPPLanguage.ID)) {
				// null IASTTranslationUnit when we're doing C/C++ means we should quit.
				// but want to continue to see if this is a fortran file we are analyzing.
				if (atu == null) {// this is null for Fortran file during JUnit testing.
					System.out.println("RunAnalyseOpenMPCommandHandler.doArtifactAnalysis(), atu is null (testing?)"); //$NON-NLS-1$
					return msr;
				}
			}

			if (languageID.equals(GCCLanguage.ID)) {// cdt40
				atu.accept(new OpenMPCASTVisitor(includes, fileName, allowPrefixOnlyMatch, msr));
			} else {
				// Attempt to handle Fortran
				// Instantiate using reflection to avoid static Photran
				// dependencies
				try {
					Class<?> c = Class.forName("org.eclipse.ptp.pldt.openmp.fortran.actions.AnalyseOpenMPFortranHandler"); //$NON-NLS-1$
					Method method = c.getMethod("run", String.class, ITranslationUnit.class, String.class, ScanReturn.class); //$NON-NLS-1$
					method.invoke(c.newInstance(), languageID, tu, fileName, msr);
				} catch (Exception e) {
					System.err.println("RunAnalyseOpenMPcommandHandler.doArtifactAnalysis: Photran not installed"); //$NON-NLS-1$
				}
			}
		} catch (CoreException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		IResource res = tu.getResource();
		IFile file = null;
		if (res instanceof IFile) {
			file = (IFile) res;
		} else {
			System.out.println("RunAnalyseOpenMP.doArtifactAnalysis, file cast won't work..."); //$NON-NLS-1$
		}
		// Find the OpenMP #pragmas
		if (atu != null) { // not for Fortran
			processOpenMPPragmas(msr, atu, file);
		}
		return msr;
	}

	/**
	 * Special processing to find #pragmas, since the CDT AST does not normally include them.<br>
	 * Also adds the "OpenMP Problems"
	 * 
	 * @param msr
	 * @param astTransUnit
	 * @param iFile
	 */
	protected void processOpenMPPragmas(OpenMPScanReturn msr, IASTTranslationUnit astTransUnit, IFile iFile) {
		OpenMPAnalysisManager omgr = new OpenMPAnalysisManager(astTransUnit, iFile);
		PASTNode[] pList = omgr.getPAST();

		for (int i = 0; i < pList.length; i++) {// length local=3271; remote 4 (!!)
			PASTNode temp = pList[i];
			String tempStr = temp.getRawSignature();
			// local: will be a PASTOMPPragma node; remote: will be a PASTPragma node.
			// So workaround is to accept a PASTPragma node here so we can handle remote files.
			// Need to investigate what this does to further analysis e.g. concurrency analysis.
			if (pList[i] instanceof PASTPragma) {// was PASTOMPPragma

				PASTPragma pop = (PASTPragma) pList[i];
				if (traceOn) {
					System.out.println("found #pragma, line " + pop.getStartingLine()); //$NON-NLS-1$
				}
				SourceInfo si = getSourceInfo(pop, Artifact.PRAGMA);
				String shortName = pop.getContent();
				if (shortName.length() == 0) {
					shortName = "#pragma"; // HACK: workaround for remote files where getContent() is always empty.
					// The same reason why this is empty is also (I think) why it's not a PASTOMPPragma node.
					// PASTOMPFactory.parse() always finds empty token first on a remote file, so aborts.
				}
				Artifact a = new Artifact(pop.getFilename(), pop.getStartingLine(), pop.getStartLocation(), shortName,
						OPENMP_DIRECTIVE, si, pop);
				msr.addArtifact(a);
			}
		}

		msr.addProblems(OpenMPErrorManager.getCurrentErrorManager().getErrors());
	}

	/**
	 * Get exact source locational info for a function call
	 * 
	 * @param pastNode
	 * @param constructType
	 * @return
	 */
	private SourceInfo getSourceInfo(PASTNode pastNode, int constructType) {
		SourceInfo sourceInfo = null;
		IASTNodeLocation[] locations = pastNode.getNodeLocations();
		if (locations.length == 1) {
			IASTFileLocation astFileLocation = null;
			if (locations[0] instanceof IASTFileLocation) {
				astFileLocation = (IASTFileLocation) locations[0];
				sourceInfo = new SourceInfo();
				sourceInfo.setStartingLine(astFileLocation.getStartingLineNumber());
				sourceInfo.setStart(astFileLocation.getNodeOffset());
				sourceInfo.setEnd(astFileLocation.getNodeOffset() + astFileLocation.getNodeLength());
				sourceInfo.setConstructType(constructType);
			}
		}
		return sourceInfo;
	}

	/**




/*******************************************************************************
 * Copyright (c) 2007, 2011, 2012 IBM Corporation, University of Illinois, and others.
 * 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
 *     Jeff Overbey (UIUC) - modified to use extension point
 *******************************************************************************/
package org.eclipse.ptp.pldt.openmp.core.analysis;

import java.util.List;

import org.eclipse.cdt.core.dom.ast.IASTFileLocation;
import org.eclipse.cdt.core.dom.ast.IASTNodeLocation;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.core.resources.IFile;
import org.eclipse.ptp.pldt.common.Artifact;
import org.eclipse.ptp.pldt.common.ArtifactAnalysisBase;
import org.eclipse.ptp.pldt.common.IArtifactAnalysis;
import org.eclipse.ptp.pldt.common.ScanReturn;
import org.eclipse.ptp.pldt.common.util.SourceInfo;
import org.eclipse.ptp.pldt.openmp.analysis.OpenMPAnalysisManager;
import org.eclipse.ptp.pldt.openmp.analysis.OpenMPErrorManager;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTNode;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTPragma;
import org.eclipse.ptp.pldt.openmp.core.OpenMPScanReturn;
import org.eclipse.ptp.pldt.openmp.core.messages.Messages;

/**
 * OpenMP artifact analysis for C.
 * <p>
 * Contributed to the <code>org.eclipse.ptp.pldt.openmp.core.artifactAnalysis</code> extension point.
 * 
 * @author Beth Tibbitts
 * @author Jeff Overbey
 */
public class OpenMPCArtifactAnalysis extends ArtifactAnalysisBase implements IArtifactAnalysis {

	private static final String OPENMP_DIRECTIVE = Messages.RunAnalyseOpenMPcommandHandler_OpenMP_directive;

	public ScanReturn runArtifactAnalysis(String languageID, ITranslationUnit tu, List<String> includes, boolean allowPrefixOnlyMatch) {
		final OpenMPScanReturn msr = new OpenMPScanReturn();
		final String fileName = tu.getElementName();
		final IASTTranslationUnit atu = getAST(tu); // use index; was tu.getAST()
		if (atu != null) {
			atu.accept(new OpenMPCASTVisitor(includes, fileName, allowPrefixOnlyMatch, msr));

			// Find the OpenMP #pragmas
			if (tu.getResource() instanceof IFile) {
				processOpenMPPragmas(msr, atu, (IFile) tu.getResource());
			}
		}
		return msr;
	}


	/**
	 * Special processing to find #pragmas, since the CDT AST does not normally include them.<br>
	 * Also adds the "OpenMP Problems"
	 * 
	 * @param msr
	 * @param astTransUnit
	 * @param iFile
	 */
	protected void processOpenMPPragmas(OpenMPScanReturn msr, IASTTranslationUnit astTransUnit, IFile iFile) {
		OpenMPAnalysisManager omgr = new OpenMPAnalysisManager(astTransUnit, iFile);
		PASTNode[] pList = omgr.getPAST();

		for (int i = 0; i < pList.length; i++) {// length local=3271; remote 4 (!!)
			PASTNode temp = pList[i];
			String tempStr = temp.getRawSignature();
			// local: will be a PASTOMPPragma node; remote: will be a PASTPragma node.
			// So workaround is to accept a PASTPragma node here so we can handle remote files.
			// Need to investigate what this does to further analysis e.g. concurrency analysis.
			if (pList[i] instanceof PASTPragma) {// was PASTOMPPragma

				PASTPragma pop = (PASTPragma) pList[i];
				//if (traceOn) {
				//	System.out.println("found #pragma, line " + pop.getStartingLine()); //$NON-NLS-1$
				//}
				SourceInfo si = getSourceInfo(pop, Artifact.PRAGMA);
				String shortName = pop.getContent();
				if (shortName.length() == 0) {
					shortName = "#pragma"; // HACK: workaround for remote files where getContent() is always empty.
					// The same reason why this is empty is also (I think) why it's not a PASTOMPPragma node.
					// PASTOMPFactory.parse() always finds empty token first on a remote file, so aborts.
				}
				Artifact a = new Artifact(pop.getFilename(), pop.getStartingLine(), pop.getStartLocation(), shortName,
						OPENMP_DIRECTIVE, si, pop);
				msr.addArtifact(a);
			}
		}

		msr.addProblems(OpenMPErrorManager.getCurrentErrorManager().getErrors());
	}


	/**
	 * Get exact source locational info for a function call
	 * 
	 * @param pastNode
	 * @param constructType
	 * @return
	 */
	private SourceInfo getSourceInfo(PASTNode pastNode, int constructType) {
		SourceInfo sourceInfo = null;
		IASTNodeLocation[] locations = pastNode.getNodeLocations();
		if (locations.length == 1) {
			IASTFileLocation astFileLocation = null;
			if (locations[0] instanceof IASTFileLocation) {
				astFileLocation = (IASTFileLocation) locations[0];
				sourceInfo = new SourceInfo();
				sourceInfo.setStartingLine(astFileLocation.getStartingLineNumber());
				sourceInfo.setStart(astFileLocation.getNodeOffset());
				sourceInfo.setEnd(astFileLocation.getNodeOffset() + astFileLocation.getNodeLength());
				sourceInfo.setConstructType(constructType);
			}
		}
		return sourceInfo;
	}
}

Lines 3-6 output.. = bin/ Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.openmp.fortran/build.properties (-1 / +2 lines)
3	bin.includes = META-INF/,\	3	bin.includes = META-INF/,\
4	.,\	4	.,\
5	plugin.properties,\	5	plugin.properties,\
6	about.html	6	about.html,\
		7	plugin.xml




<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.4"?>
<plugin>

   <!-- OpenMP artifact analysis for Fortran -->
   <extension point="org.eclipse.ptp.pldt.openmp.core.artifactAnalysis">
      <artifactAnalysis
            languageID="org.eclipse.photran.cdtinterface.fortran"
            class="org.eclipse.ptp.pldt.openmp.fortran.analysis.OpenMPFortranArtifactAnalysis" />
   </extension>

</plugin>




/**********************************************************************
 * Copyright (c) 2010 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.fortran.actions;

import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.photran.internal.cdtinterface.core.FortranLanguage;
import org.eclipse.photran.internal.core.lexer.ASTLexerFactory;
import org.eclipse.photran.internal.core.parser.ASTExecutableProgramNode;
import org.eclipse.photran.internal.core.parser.Parser;
import org.eclipse.ptp.pldt.common.ScanReturn;
import org.eclipse.ptp.pldt.openmp.fortran.analysis.OpenMPFortranASTVisitor;

/**
 * @since 4.0
 */
public class AnalyseOpenMPFortranHandler {
	public void run(String languageID, ITranslationUnit tu, String fileName, ScanReturn msr) {
		if (languageID.equals(FortranLanguage.LANGUAGE_ID)) {
			IResource res = tu.getUnderlyingResource();
			if (!(res instanceof IFile))
				throw new IllegalStateException();
			IFile file = (IFile) res;

			try {
				ASTExecutableProgramNode ast = new Parser().parse(new ASTLexerFactory().createLexer(file));
				ast.accept(new OpenMPFortranASTVisitor(fileName, msr));
			} catch (Exception e) {
				e.printStackTrace(); // TODO
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2012 University of Illinois at Urbana-Champaign and others.
 * 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:
 *     UIUC - Initial API and implementation
 *******************************************************************************/
package org.eclipse.ptp.pldt.openmp.fortran.analysis;

import java.util.List;

import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.photran.internal.cdtinterface.core.FortranLanguage;
import org.eclipse.photran.internal.core.lexer.ASTLexerFactory;
import org.eclipse.photran.internal.core.parser.ASTExecutableProgramNode;
import org.eclipse.photran.internal.core.parser.Parser;
import org.eclipse.ptp.pldt.common.IArtifactAnalysis;
import org.eclipse.ptp.pldt.common.ScanReturn;

/**
 * OpenMP artifact analysis for Fortran.
 * <p>
 * Contributed to the <code>org.eclipse.ptp.pldt.mpi.core.artifactAnalysis</code> extension point.
 * 
 * @author Jeff Overbey
 */
public class OpenMPFortranArtifactAnalysis implements IArtifactAnalysis {
	public ScanReturn runArtifactAnalysis(String languageID, ITranslationUnit tu, List<String> includes, boolean allowPrefixOnlyMatch) {
		final ScanReturn msr = new ScanReturn();
		final String fileName = tu.getElementName();
		if (languageID.equals(FortranLanguage.LANGUAGE_ID)) {
			IResource res = tu.getUnderlyingResource();
			if (!(res instanceof IFile))
				throw new IllegalStateException();
			IFile file = (IFile) res;

			try {
				ASTExecutableProgramNode ast = new Parser().parse(new ASTLexerFactory().createLexer(file));
				ast.accept(new OpenMPFortranASTVisitor(fileName, msr));
			} catch (Exception e) {
				e.printStackTrace(); // TODO
			}
		}
		return msr;
	}
}

Return to bug 373597

Lines 119-128 Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.mpi.core/plugin.xml (-2 / +17 lines)
119		119
120	</menuContribution>	120	</menuContribution>
121	</extension>	121	</extension>
122	<!-- Code templates -->	122
		123	<!-- Code templates -->
123	<extension point="org.eclipse.ui.editors.templates">	124	<extension point="org.eclipse.ui.editors.templates">
124	<include file="templates/mpi_templates.xml" />	125	<include file="templates/mpi_templates.xml" />
		126	</extension>
125		127
		128	<!-- Artifact analysis extension point -->
		129	<extension-point
		130	id="artifactAnalysis"
		131	name="MPI Artifact Analysis"
		132	schema="schema/artifactAnalysis.exsd"/>
		133	<!-- Artifact analyses for C and C++ -->
		134	<extension point="org.eclipse.ptp.pldt.mpi.core.artifactAnalysis">
		135	<artifactAnalysis
		136	languageID="org.eclipse.cdt.core.gcc"
		137	class="org.eclipse.ptp.pldt.mpi.core.analysis.CMPIArtifactAnalysis" />
		138	<artifactAnalysis
		139	languageID="org.eclipse.cdt.core.g++"
		140	class="org.eclipse.ptp.pldt.mpi.core.analysis.CMPIArtifactAnalysis" />
126	</extension>	141	</extension>
127		142
128	</plugin>	143	</plugin>

Added Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.common/src/org/eclipse/ptp/pldt/common/ArtifactAnalysisBase.java (+49 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007, 2011, 2012 IBM Corporation, University of Illinois, and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	* Jeff Overbey (UIUC) - modified to use extension point
11	*******************************************************************************/
12	package org.eclipse.ptp.pldt.common;
13
14	import org.eclipse.cdt.core.CCorePlugin;
15	import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
16	import org.eclipse.cdt.core.index.IIndex;
17	import org.eclipse.cdt.core.model.ITranslationUnit;
18	import org.eclipse.core.runtime.IStatus;
19
20	/**
21	* Base class for implementations of {@link IArtifactAnalysis} that handle C and
22	* C++.
23	* <p>
24	* This class contains the {@link #getAST(ITranslationUnit)} utility method,
25	* which returns an {@link IASTTranslationUnit} for an {@link ITranslationUnit}.
26	*
27	* @author Beth Tibbitts
28	* @author Jeff Overbey
29	*
30	* @since 6.0
31	*/
32	public abstract class ArtifactAnalysisBase implements IArtifactAnalysis {
33	/**
34	* Get AST from index, not full tu
35	*
36	* @param tu
37	* translation unit from which to get the AST
38	* @return {@link IASTTranslationUnit} or <code>null</code>
39	*/
40	protected IASTTranslationUnit getAST(ITranslationUnit tu) {
41	try {
42	IIndex index = CCorePlugin.getIndexManager().getIndex(tu.getCProject());
43	return tu.getAST(index, ITranslationUnit.AST_SKIP_ALL_HEADERS);
44	} catch (Exception e) {
45	CommonPlugin.log(IStatus.ERROR, "RunAnalyseHandlerBase.getAST(): Error getting AST (from index) for project " + tu.getCProject() + " " + e.getMessage()); //$NON-NLS-1$
46	return null;
47	}
48	}
49	}

Added Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.common/src/org/eclipse/ptp/pldt/common/IArtifactAnalysis.java (+25 lines)
1	package org.eclipse.ptp.pldt.common;
2
3	import java.util.List;
4
5	import org.eclipse.cdt.core.model.ITranslationUnit;
6
7	/**
8	* An artifact analysis for MPI, OpenMP, or OpenACC.
9	* <p>
10	* This interface is implemented by contributions to the following extension points:
11	* <ul>
12	* <li> org.eclipse.ptp.pldt.mpi.core.artifactAnalysis
13	* <li> org.eclipse.ptp.pldt.openmp.core.artifactAnalysis
14	* <li> org.eclipse.ptp.pldt.openacc.artifactAnalysis
15	* </ul>
16	* <p>
17	* Implementations targeting C and C++ will typically subclass {@link ArtifactAnalysisBase}.
18	*
19	* @since 6.0
20	*
21	* @see ArtifactAnalysisBase
22	*/
23	public interface IArtifactAnalysis {
24	ScanReturn runArtifactAnalysis(String languageID, ITranslationUnit tu, List<String> includes, boolean allowPrefixOnlyMatch);
25	}

Added Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.mpi.core/schema/artifactAnalysis.exsd (+88 lines)
1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.ptp.pldt.mpi.core" xmlns="http://www.w3.org/2001/XMLSchema">
4	<annotation>
5	<appInfo>
6	<meta.schema plugin="org.eclipse.ptp.pldt.mpi.core" id="artifactAnalysis" name="MPI Artifact Analysis"/>
7	</appInfo>
8	<documentation>
9	Allows plug-ins to contribute MPI artifact analyses.
10	</documentation>
11	</annotation>
12
13	<element name="extension">
14	<annotation>
15	<appInfo>
16	<meta.element />
17	</appInfo>
18	</annotation>
19	<complexType>
20	<sequence minOccurs="1" maxOccurs="unbounded">
21	<element ref="artifactAnalysis"/>
22	</sequence>
23	<attribute name="point" type="string" use="required">
24	<annotation>
25	<documentation>
26
27	</documentation>
28	</annotation>
29	</attribute>
30	<attribute name="id" type="string">
31	<annotation>
32	<documentation>
33
34	</documentation>
35	</annotation>
36	</attribute>
37	<attribute name="name" type="string">
38	<annotation>
39	<documentation>
40
41	</documentation>
42	<appInfo>
43	<meta.attribute translatable="true"/>
44	</appInfo>
45	</annotation>
46	</attribute>
47	</complexType>
48	</element>
49
50	<element name="artifactAnalysis">
51	<complexType>
52	<attribute name="languageID" type="string" use="required">
53	<annotation>
54	<documentation>
55
56	</documentation>
57	<appInfo>
58	<meta.attribute kind="identifier" basedOn="org.eclipse.cdt.core.language/language/@id"/>
59	</appInfo>
60	</annotation>
61	</attribute>
62	<attribute name="class" type="string" use="required">
63	<annotation>
64	<documentation>
65
66	</documentation>
67	<appInfo>
68	<meta.attribute kind="java" basedOn=":org.eclipse.ptp.pldt.common.IArtifactAnalysis"/>
69	</appInfo>
70	</annotation>
71	</attribute>
72	</complexType>
73	</element>
74
75	<annotation>
76	<appInfo>
77	<meta.section type="since"/>
78	</appInfo>
79	<documentation>
80	6.0
81	</documentation>
82	</annotation>
83
84
85
86
87
88	</schema>

Added Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.mpi.fortran/plugin.xml (+20 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<?eclipse version="3.4"?>
3	<plugin>
4
5	<!-- MPI artifact analysis for Fortran -->
6	<extension point="org.eclipse.ptp.pldt.mpi.core.artifactAnalysis">
7	<artifactAnalysis
8	languageID="org.eclipse.photran.cdtinterface.fortran"
9	class="org.eclipse.ptp.pldt.mpi.fortran.analysis.MPIFortranArtifactAnalysis" />
10	</extension>
11
12	<!-- Dynamic help for MPI in the Photran editor -->
13	<extension
14	point="org.eclipse.photran.ui.apiHelpProvider">
15	<apiHelpProvider
16	class="org.eclipse.ptp.pldt.mpi.fortran.editorHelp.MpiFortranHelpProvider">
17	</apiHelpProvider>
18	</extension>
19
20	</plugin>

Added Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.mpi.fortran/src/org/eclipse/ptp/pldt/mpi/fortran/analysis/MPIFortranASTVisitor.java (+71 lines)
1	/**********************************************************************
2	* Copyright (c) 2005, 2010 IBM Corporation.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ptp.pldt.mpi.fortran.analysis;
12
13	import org.eclipse.photran.internal.core.lexer.Token;
14	import org.eclipse.photran.internal.core.parser.ASTCallStmtNode;
15	import org.eclipse.photran.internal.core.parser.ASTNameNode;
16	import org.eclipse.photran.internal.core.parser.ASTVarOrFnRefNode;
17	import org.eclipse.photran.internal.core.parser.GenericASTVisitor;
18	import org.eclipse.ptp.pldt.common.Artifact;
19	import org.eclipse.ptp.pldt.common.ScanReturn;
20	import org.eclipse.ptp.pldt.common.util.SourceInfo;
21
22	/**
23	* This dom-walker collects "artifacts" related to the specific domain <br>
24	* (e.g. MPI, OpenMP, etc.). Currently these artifacts include function calls
25	* and constants. It adds markers to the source file for C code, marking the
26	* position of the artifacts found.
27	*
28	* @author Beth Tibbitts
29	* @since 4.0
30	*
31	*/
32	public class MPIFortranASTVisitor extends GenericASTVisitor {
33	private static final String PREFIX = "MPI_"; //$NON-NLS-1$
34
35	@SuppressWarnings("unused")
36	private static final boolean traceOn = false;
37	private final ScanReturn scanReturn;
38	private final String fileName;
39
40	@Override
41	public void visitASTCallStmtNode(ASTCallStmtNode node) {
42	Token subroutineName = node.getSubroutineName();
43	addArtifact(subroutineName, Artifact.FUNCTION_CALL);
44	}
45
46	@Override
47	public void visitASTVarOrFnRefNode(ASTVarOrFnRefNode node) {
48	ASTNameNode nameNode = node.getName();
49	if (nameNode != null) {
50	Token varName = nameNode.getName();
51	addArtifact(varName, Artifact.CONSTANT);
52	}
53	}
54
55	private void addArtifact(Token subroutineName, int artifactType) {
56	String callname = subroutineName.getText().toUpperCase();
57	if (callname.startsWith(PREFIX)) {
58	int start = subroutineName.getFileOffset();
59	int end = subroutineName.getFileOffset() + subroutineName.getLength();
60	SourceInfo si = new SourceInfo(subroutineName.getLine(), start, end, artifactType);
61	scanReturn.addArtifact(new Artifact(fileName, subroutineName.getLine(), 1, callname, si));
62	}
63	}
64
65	public MPIFortranASTVisitor(String fileName, ScanReturn scanReturn) {
66	super();
67	this.scanReturn = scanReturn;
68	this.fileName = fileName;
69	}
70
71	}

Added Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.mpi.fortran/src/org/eclipse/ptp/pldt/mpi/fortran/analysis/MPIFortranArtifactAnalysis.java (+33 lines)
1	/*******************************************************************************
2	* Copyright (c) 2012 University of Illinois at Urbana-Champaign and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* UIUC - Initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ptp.pldt.mpi.fortran.analysis;
12
13	import java.util.List;
14
15	import org.eclipse.cdt.core.model.ITranslationUnit;
16	import org.eclipse.ptp.pldt.common.IArtifactAnalysis;
17	import org.eclipse.ptp.pldt.common.ScanReturn;
18	import org.eclipse.ptp.pldt.mpi.fortran.actions.AnalyseMPIFortranHandler;
19
20	/**
21	* MPI artifact analysis for Fortran.
22	* <p>
23	* Contributed to the <code>org.eclipse.ptp.pldt.mpi.core.artifactAnalysis</code> extension point.
24	*
25	* @author Jeff Overbey
26	*/
27	public class MPIFortranArtifactAnalysis implements IArtifactAnalysis {
28	public ScanReturn runArtifactAnalysis(String languageID, ITranslationUnit tu, List<String> includes, boolean allowPrefixOnlyMatch) {
29	final ScanReturn msr = new ScanReturn();
30	new AnalyseMPIFortranHandler().run(languageID, tu, tu.getElementName(), msr);
31	return msr;
32	}
33	}

Added Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.mpi.fortran/src/org/eclipse/ptp/pldt/mpi/fortran/editorHelp/MpiFortranHelpProvider.java (+108 lines)
1	/**********************************************************************
2	* Copyright (c) 2005, 2011 IBM Corporation.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ptp.pldt.mpi.fortran.editorHelp;
12
13	import java.io.IOException;
14	import java.io.InputStream;
15	import java.net.URL;
16	import java.util.Collections;
17	import java.util.HashMap;
18	import java.util.Map;
19
20	import javax.xml.parsers.DocumentBuilder;
21	import javax.xml.parsers.DocumentBuilderFactory;
22
23	import org.eclipse.core.runtime.FileLocator;
24	import org.eclipse.core.runtime.Path;
25	import org.eclipse.core.runtime.Platform;
26	import org.eclipse.help.IHelpResource;
27	import org.eclipse.photran.ui.IFortranAPIHelpProvider;
28	import org.eclipse.ptp.pldt.mpi.core.MpiPlugin;
29	import org.eclipse.ptp.pldt.mpi.fortran.Activator;
30	import org.eclipse.ui.texteditor.ITextEditor;
31	import org.w3c.dom.Document;
32	import org.w3c.dom.Node;
33	import org.w3c.dom.NodeList;
34
35	/**
36	* Help book for Fortran MPI functions
37	*
38	* @author Beth Tibbitts
39	* @author Jeff Overbey
40	*/
41	public class MpiFortranHelpProvider implements IFortranAPIHelpProvider {
42	private final Map<String, String> fNameToCname;
43
44	/**
45	* builds the list of function summaries by parsing an XML file
46	*/
47	public MpiFortranHelpProvider() {
48	Map<String, String> fNameToCname;
49	URL fileURL = FileLocator.find(Platform.getBundle(MpiPlugin.getPluginId()), new Path("mpiref.xml"), null); //$NON-NLS-1$
50	try {
51	fNameToCname = parseDOM(fileURL.openStream());
52	} catch (IOException e) {
53	Activator.log(e);
54	fNameToCname = Collections.<String, String>emptyMap();
55	}
56	this.fNameToCname = fNameToCname;
57	}
58
59	public static Map<String, String> parseDOM(InputStream xmlIn) {
60	final Map<String, String> fNameToCname = new HashMap<String, String>();
61	if (xmlIn != null)
62	{
63	try {
64	DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
65	Document document = builder.parse(xmlIn);
66	NodeList functionList = document.getElementsByTagName("function");//$NON-NLS-1$
67	for (int i = 0; i < functionList.getLength(); i++) {
68	Node func = functionList.item(i);
69	NodeList child = func.getChildNodes();
70	String fname = null;
71	String cname = null;
72	// String desc = null;
73	for (int j = 0; j < child.getLength(); j++) {
74	Node sub = child.item(j);
75	if (sub.getNodeName().equals("cname")) {
76	cname = sub.getTextContent(); // java 5
77	//} else if (sub.getNodeName().equals("description")) {//$NON-NLS-1$
78	// desc = sub.getTextContent(); // java 5
79	} else if (sub.getNodeName().equals("fname")) {//$NON-NLS-1$
80	fname = sub.getTextContent(); // java 5
81	}
82	}
83	if (fname != null && cname != null) {
84	fNameToCname.put(fname.toUpperCase(), cname);
85	}
86	}
87	} catch (Exception e) {
88	Activator.log(e);
89	}
90	}
91	return fNameToCname;
92	}
93
94	public IHelpResource[] getHelpResources(ITextEditor fortranEditor, String name, String precedingText) {
95	final String fname = name.toUpperCase();
96	if (fNameToCname.containsKey(fname)) {
97	return new IHelpResource[] { new IHelpResource() {
98	public String getHref() {
99	return String.format("/%s/html/%s.html", MpiPlugin.getPluginId(), fNameToCname.get(fname));
100	}
101	public String getLabel() {
102	return fname;
103	}
104	} };
105	}
106	return null;
107	}
108	}

Lines 27-42 public class OpenACCFortranHelpProvider implements IFortranAPIHelpProvider { Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.openacc.fortran/src/org/eclipse/ptp/pldt/openacc/internal/fortran/editorHelp/OpenACCFortranHelpProvider.java (-5 / +18 lines)
27	/** Plug-in ID for the main (non-Fortran) OpenACC plug-in, which contains HTML documentation. */	27	/** Plug-in ID for the main (non-Fortran) OpenACC plug-in, which contains HTML documentation. */
28	private static final String OPENACC_PLUGIN_ID = "org.eclipse.ptp.pldt.openacc"; //$NON-NLS-1$	28	private static final String OPENACC_PLUGIN_ID = "org.eclipse.ptp.pldt.openacc"; //$NON-NLS-1$
29		29
30	/** Regular expression matching the start of an OpenACC directive */	30	/** Pattern matching the start of an OpenACC directive */
31	private static final Pattern OPENACC_DIRECTIVE_PREFIX = Pattern	31	private static final Pattern OPENACC_DIRECTIVE_PREFIX_PATTERN = Pattern
32	.compile("(^[Cc]\|[ \\t]!)\\$acc([ \\t]+end)?([ \\t]+parallel)?[ \\t]*"); //$NON-NLS-1$	32	.compile("(^[Cc]\|[ \\t]!)\\$acc([ \\t]+end)?([ \\t]+parallel)?[ \\t]*"); //$NON-NLS-1$
33		33
		34	/** Format string for an OpenACC directive. %s is replaced with a directive name. */
		35	private static final String OPENACC_DIRECTIVE_REGEX_FORMAT =
		36	"(^[Cc]\|[ \\t]!)\\$acc([ \\t]+end)?([ \\t]+parallel)?[ \\t]+%s.*"; //$NON-NLS-1$
		37
34	private final Set<String> procedures = new HashSet<String>(32);	38	private final Set<String> procedures = new HashSet<String>(32);
35	private final Set<String> directives = new HashSet<String>(32);	39	private final Set<String> directives = new HashSet<String>(32);
36		40
37	/** Constructor */	41	/** Constructor */
38	public OpenACCFortranHelpProvider() {	42	public OpenACCFortranHelpProvider() {
39	procedures.add("acc_get_num_devices"); // OpenACC Application Programming Interface, Version 1.0, Section 3.2.1 //$NON-NLS-1$	43	// Section numbers from the OpenACC specification: "The OpenACC Application Programming Interface, Version 1.0"
		44	procedures.add("acc_get_num_devices"); // Section 3.2.1 //$NON-NLS-1$
40	procedures.add("acc_set_device_type"); // 3.2.2 //$NON-NLS-1$	45	procedures.add("acc_set_device_type"); // 3.2.2 //$NON-NLS-1$
41	procedures.add("acc_get_device_type"); // 3.2.3 //$NON-NLS-1$	46	procedures.add("acc_get_device_type"); // 3.2.3 //$NON-NLS-1$
42	procedures.add("acc_set_device_num"); // 3.2.4 //$NON-NLS-1$	47	procedures.add("acc_set_device_num"); // 3.2.4 //$NON-NLS-1$
Lines 67-74 public class OpenACCFortranHelpProvider implements IFortranAPIHelpProvider { Link Here
67	final String fname = apiName.toLowerCase();	72	final String fname = apiName.toLowerCase();
68	if (procedures.contains(fname)) {	73	if (procedures.contains(fname)) {
69	return getHelpResourceForFilename(fname);	74	return getHelpResourceForFilename(fname);
70	} else if (directives.contains(fname) && OPENACC_DIRECTIVE_PREFIX.matcher(precedingText).matches()) {	75	} else if (OPENACC_DIRECTIVE_PREFIX_PATTERN.matcher(precedingText).find()) {
71	return getHelpResourceForFilename("pragma_acc_" + fname); //$NON-NLS-1$	76	if (directives.contains(fname)) {
		77	return getHelpResourceForFilename("pragma_acc_" + fname); //$NON-NLS-1$
		78	} else {
		79	for (String directive : directives) {
		80	if (precedingText.matches(String.format(OPENACC_DIRECTIVE_REGEX_FORMAT, directive))) {
		81	return getHelpResourceForFilename("pragma_acc_" + directive); //$NON-NLS-1$
		82	}
		83	}
		84	}
72	}	85	}
73	return null;	86	return null;
74	}	87	}

Lines 1-7 Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.openacc.fortran/templates/openacc_templates.xml (-1 / +69 lines)
1	<?xml version="1.0" encoding="UTF-8" standalone="no"?>	1	<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2	<templates>	2	<templates>
		3	<template id="org.eclipse.ptp.pldt.openacc.fortran.cache"
		4	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		5	deleted="false" description="OpenACC cache directive" enabled="true"
		6	name="!$acc cache">!$$acc cache (${cursor})</template>
		7	<template id="org.eclipse.ptp.pldt.openacc.fortran.data"
		8	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		9	deleted="false" description="OpenACC data directive" enabled="true"
		10	name="!$acc data">!$$acc data${cursor}</template>
		11	<template id="org.eclipse.ptp.pldt.openacc.fortran.endd_ata"
		12	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		13	deleted="false" description="OpenACC end data directive" enabled="true"
		14	name="!$acc end data">!$$acc end data${cursor}</template>
		15	<template id="org.eclipse.ptp.pldt.openacc.fortran.declare"
		16	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		17	deleted="false" description="OpenACC declare directive" enabled="true"
		18	name="!$acc declare">!$$acc declare ${cursor}</template>
		19	<template id="org.eclipse.ptp.pldt.openacc.fortran.host_data"
		20	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		21	deleted="false" description="OpenACC host_data directive" enabled="true"
		22	name="!$acc host_data">!$$acc host_data${cursor}</template>
		23	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_host_data"
		24	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		25	deleted="false" description="OpenACC end host_data directive" enabled="true"
		26	name="!$acc end host_data">!$$acc end host_data${cursor}</template>
		27	<template id="org.eclipse.ptp.pldt.openacc.fortran.kernels"
		28	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		29	deleted="false" description="OpenACC kernels directive" enabled="true"
		30	name="!$acc kernels">!$$acc kernels${cursor}</template>
		31	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_kernels"
		32	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		33	deleted="false" description="OpenACC end kernels directive" enabled="true"
		34	name="!$acc end kernels">!$$acc end kernels${cursor}</template>
		35	<template id="org.eclipse.ptp.pldt.openacc.fortran.kernels_loop"
		36	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		37	deleted="false" description="OpenACC kernels loop directive" enabled="true"
		38	name="!$acc kernels loop">!$$acc kernels loop${cursor}</template>
		39	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_kernels_loop"
		40	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		41	deleted="false" description="OpenACC end kernels loop directive" enabled="true"
		42	name="!$acc end kernels loop">!$$acc end kernels loop${cursor}</template>
		43	<template id="org.eclipse.ptp.pldt.openacc.fortran.loop"
		44	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		45	deleted="false" description="OpenACC loop directive" enabled="true"
		46	name="!$acc loop">!$$acc loop${cursor}</template>
		47	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_loop"
		48	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		49	deleted="false" description="OpenACC end loop directive" enabled="true"
		50	name="!$acc end loop">!$$acc end loop${cursor}</template>
3	<template id="org.eclipse.ptp.pldt.openacc.fortran.parallel"	51	<template id="org.eclipse.ptp.pldt.openacc.fortran.parallel"
4	autoinsert="true" context="org.eclipse.photran.ui.template.context"	52	autoinsert="true" context="org.eclipse.photran.ui.template.context"
5	deleted="false" description="OpenACC parallel directive" enabled="true"	53	deleted="false" description="OpenACC parallel directive" enabled="true"
6	name="!$acc parallel">!$$acc parallel${cursor}</template>	54	name="!$acc parallel">!$$acc parallel${cursor}</template>
7	</templates>	55	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_parallel"
		56	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		57	deleted="false" description="OpenACC end parallel directive" enabled="true"
		58	name="!$acc end parallel">!$$acc end parallel${cursor}</template>
		59	<template id="org.eclipse.ptp.pldt.openacc.fortran.parallel_loop"
		60	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		61	deleted="false" description="OpenACC parallel loop directive" enabled="true"
		62	name="!$acc parallel loop">!$$acc parallel loop${cursor}</template>
		63	<template id="org.eclipse.ptp.pldt.openacc.fortran.end_parallel_loop"
		64	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		65	deleted="false" description="OpenACC end parallel loop directive" enabled="true"
		66	name="!$acc end parallel loop">!$$acc end parallel loop${cursor}</template>
		67	<template id="org.eclipse.ptp.pldt.openacc.fortran.update"
		68	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		69	deleted="false" description="OpenACC update directive" enabled="true"
		70	name="!$acc update">!$$acc update ${cursor}</template>
		71	<template id="org.eclipse.ptp.pldt.openacc.fortran.wait"
		72	autoinsert="true" context="org.eclipse.photran.ui.template.context"
		73	deleted="false" description="OpenACC wait directive" enabled="true"
		74	name="!$acc wait">!$$acc wait${cursor}</template>
		75	</templates>

Lines 93-98 Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.openacc/plugin.xml (+15 lines)
93	</initializer>	93	</initializer>
94	</extension>	94	</extension>
95		95
		96	<!-- OpenACC artifact analysis extension point -->
		97	<extension-point
		98	id="artifactAnalysis"
		99	name="OpenACC Artifact Analysis"
		100	schema="schema/artifactAnalysis.exsd"/>
		101	<!-- OpenACC atifact analyses for C and C++ -->
		102	<extension point="org.eclipse.ptp.pldt.openacc.artifactAnalysis">
		103	<artifactAnalysis
		104	languageID="org.eclipse.cdt.core.gcc"
		105	class="org.eclipse.ptp.pldt.openacc.internal.actions.OpenACCCArtifactAnalysis" />
		106	<artifactAnalysis
		107	languageID="org.eclipse.cdt.core.g++"
		108	class="org.eclipse.ptp.pldt.openacc.internal.actions.OpenACCCArtifactAnalysis" />
		109	</extension>
		110
96	<!-- OpenACC C help book -->	111	<!-- OpenACC C help book -->
97	<extension	112	<extension
98	point="org.eclipse.cdt.ui.CHelpProvider">	113	point="org.eclipse.cdt.ui.CHelpProvider">

Lines 105-108 Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.openmp.core/plugin.xml (+16 lines)
105	class="org.eclipse.ptp.pldt.openmp.core.prefs.OpenMPPreferenceInitializer">	105	class="org.eclipse.ptp.pldt.openmp.core.prefs.OpenMPPreferenceInitializer">
106	</initializer>	106	</initializer>
107	</extension>	107	</extension>
		108
		109	<!-- Artifact analysis extension point -->
		110	<extension-point
		111	id="artifactAnalysis"
		112	name="OpenMP Artifact Analysis"
		113	schema="schema/artifactAnalysis.exsd"/>
		114	<!-- Artifact analysis for C -->
		115	<extension point="org.eclipse.ptp.pldt.openmp.core.artifactAnalysis">
		116	<artifactAnalysis
		117	languageID="org.eclipse.cdt.core.gcc"
		118	class="org.eclipse.ptp.pldt.openmp.core.analysis.OpenMPCArtifactAnalysis" />
		119	<artifactAnalysis
		120	languageID="org.eclipse.cdt.core.g++"
		121	class="org.eclipse.ptp.pldt.openmp.core.analysis.OpenMPCArtifactAnalysis" />
		122	</extension>
		123
108	</plugin>	124	</plugin>

Lines 1-43 Link Here

(-)tools/pldt/org.eclipse.ptp.pldt.openmp.fortran/src/org/eclipse/ptp/pldt/openmp/fortran/actions/AnalyseOpenMPFortranHandler.java (-43 lines)
1	/**********************************************************************
2	* Copyright (c) 2010 IBM Corporation.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.ptp.pldt.openmp.fortran.actions;
13
14	import org.eclipse.cdt.core.model.ITranslationUnit;
15	import org.eclipse.core.resources.IFile;
16	import org.eclipse.core.resources.IResource;
17	import org.eclipse.photran.internal.cdtinterface.core.FortranLanguage;
18	import org.eclipse.photran.internal.core.lexer.ASTLexerFactory;
19	import org.eclipse.photran.internal.core.parser.ASTExecutableProgramNode;
20	import org.eclipse.photran.internal.core.parser.Parser;
21	import org.eclipse.ptp.pldt.common.ScanReturn;
22	import org.eclipse.ptp.pldt.openmp.fortran.analysis.OpenMPFortranASTVisitor;
23
24	/**
25	* @since 4.0
26	*/
27	public class AnalyseOpenMPFortranHandler {
28	public void run(String languageID, ITranslationUnit tu, String fileName, ScanReturn msr) {
29	if (languageID.equals(FortranLanguage.LANGUAGE_ID)) {
30	IResource res = tu.getUnderlyingResource();
31	if (!(res instanceof IFile))
32	throw new IllegalStateException();
33	IFile file = (IFile) res;
34
35	try {
36	ASTExecutableProgramNode ast = new Parser().parse(new ASTLexerFactory().createLexer(file));
37	ast.accept(new OpenMPFortranASTVisitor(fileName, msr));
38	} catch (Exception e) {
39	e.printStackTrace(); // TODO
40	}
41	}
42	}
43	}