Attachment #225044 for bug #397116

Lines 3-7 Link Here

(-)a/org.eclipse.photran.cdtinterface/.classpath (+2 lines)
3	<classpathentry kind="src" path="src"/>	3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>	4	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
5	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>	5	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
		6	<classpathentry combineaccessrules="false" kind="src" path="/org.eclipse.photran.core.vpg"/>
		7	<classpathentry combineaccessrules="false" kind="src" path="/org.eclipse.rephraserengine.core"/>
6	<classpathentry kind="output" path="bin"/>	8	<classpathentry kind="output" path="bin"/>
7	</classpath>	9	</classpath>

Lines 8-13 Link Here

(-)a/org.eclipse.photran.cdtinterface/META-INF/MANIFEST.MF (-1 / +6 lines)
8	Bundle-Vendor: %providerName	8	Bundle-Vendor: %providerName
9	Bundle-Localization: plugin	9	Bundle-Localization: plugin
10	Export-Package: org.eclipse.photran.cdtinterface.makegen,	10	Export-Package: org.eclipse.photran.cdtinterface.makegen,
		11	org.eclipse.photran.cdtinterface.managebuilder,
		12	org.eclipse.photran.cdtinterface.managebuilder.gnu,
		13	org.eclipse.photran.cdtinterface.managebuilder.intel,
		14	org.eclipse.photran.cdtinterface.managebuilder.xlf,
11	org.eclipse.photran.internal.cdtinterface;x-internal:=true,	15	org.eclipse.photran.internal.cdtinterface;x-internal:=true,
12	org.eclipse.photran.internal.cdtinterface.core;x-friends:="org.eclipse.photran.ui",	16	org.eclipse.photran.internal.cdtinterface.core;x-friends:="org.eclipse.photran.ui",
13	org.eclipse.photran.internal.cdtinterface.dom;x-internal:=true,	17	org.eclipse.photran.internal.cdtinterface.dom;x-internal:=true,
Lines 41-46 Link Here
41	org.eclipse.ui.views,	45	org.eclipse.ui.views,
42	org.eclipse.cdt.managedbuilder.core,	46	org.eclipse.cdt.managedbuilder.core,
43	org.eclipse.ui.navigator.resources,	47	org.eclipse.ui.navigator.resources,
44	org.eclipse.ui.navigator	48	org.eclipse.ui.navigator,
		49	org.eclipse.photran.core.vpg;bundle-version="8.0.0"
45	Bundle-ActivationPolicy: lazy	50	Bundle-ActivationPolicy: lazy
46	Bundle-RequiredExecutionEnvironment: JavaSE-1.6	51	Bundle-RequiredExecutionEnvironment: JavaSE-1.6

Lines 7-12 Link Here

(-)a/org.eclipse.photran.cdtinterface/src/org/eclipse/photran/cdtinterface/makegen/DefaultFortranDependencyCalculator.java (-75 / +77 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM - Initial API and implementation	9	* IBM - Initial API and implementation
		10	* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
		11	* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan
		12	* - Modified to do resource lookup using Photran VPG. Fixed bug#397116
10	*******************************************************************************/	13	*******************************************************************************/
11	package org.eclipse.photran.cdtinterface.makegen;	14	package org.eclipse.photran.cdtinterface.makegen;
12		15
Lines 20-26 Link Here
20	import java.io.Reader;	23	import java.io.Reader;
21	import java.io.StreamTokenizer;	24	import java.io.StreamTokenizer;
22	import java.util.ArrayList;	25	import java.util.ArrayList;
		26	import java.util.Arrays;
23	import java.util.Collection;	27	import java.util.Collection;
		28	import java.util.List;
24		29
25	import org.eclipse.cdt.core.CCorePlugin;	30	import org.eclipse.cdt.core.CCorePlugin;
26	import org.eclipse.cdt.managedbuilder.core.IConfiguration;	31	import org.eclipse.cdt.managedbuilder.core.IConfiguration;
Lines 40-59 Link Here
40	import org.eclipse.core.runtime.Path;	45	import org.eclipse.core.runtime.Path;
41	import org.eclipse.core.runtime.content.IContentType;	46	import org.eclipse.core.runtime.content.IContentType;
42	import org.eclipse.photran.internal.cdtinterface.core.FortranLanguage;	47	import org.eclipse.photran.internal.cdtinterface.core.FortranLanguage;
		48	import org.eclipse.photran.internal.core.vpg.PhotranVPG;
43		49
44	/**	50	/**
45	* This class implements the Dependency Manager and Output Name Provider interfaces	51	* This class implements the Dependency Manager and Output Name Provider interfaces
46	* @author Unknown	52	* @author Unknown
47	* @author Timofey Yuvashev 2009	53	* @author Timofey Yuvashev 2009
48	* @author Jeff Overbey -- files were not being closed (Bug 334796)	54	* @author Jeff Overbey -- files were not being closed (Bug 334796)
49	*	55	* @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
		56	* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan
		57	* -- Use PhotranVPG to find dependencies for the given project
		58	* (Managed Build project, Fall CS 427)
		59	* -- Refactored, removed resources from getFileNameContainingModule
		60	* function since Photran VPG does not need resources argument
50	* @since 8.0	61	* @since 8.0
51	*/	62	*/
52	@SuppressWarnings({ "deprecation", "rawtypes", "unchecked", "unused" })	63	@SuppressWarnings({ "deprecation", "rawtypes", "unchecked", "unused" })
53	public class DefaultFortranDependencyCalculator implements IManagedDependencyGenerator,	64	public class DefaultFortranDependencyCalculator implements IManagedDependencyGenerator,
54	IManagedOutputNameProvider	65	IManagedOutputNameProvider
55	{	66	{
56	public static final String MODULE_EXTENSION = "o"; //$NON-NLS-1$	67	public static final String MODULE_EXTENSION = "o"; //$NON-NLS-1$
57		68
58	/*	69	/*
59	* Return a list of the names of all modules used by a file	70	* Return a list of the names of all modules used by a file
Lines 243-249 Link Here
243	// to generate .mod files in the directory from which the compiler is run. For MBS, this	254	// to generate .mod files in the directory from which the compiler is run. For MBS, this
244	// is the top-level build directory.	255	// is the top-level build directory.
245	// TODO: Support the /module:path option and use that in determining the path of the module file	256	// TODO: Support the /module:path option and use that in determining the path of the module file
246	IPath modName = getModulePath(topBuildDir, modules[im], res, project);	257	IPath modName = getModulePath(topBuildDir, modules[im], resourcesToSearch, project);
247	modRes.add(project.getFile(modName));	258	modRes.add(project.getFile(modName));
248	foundDependency = true;	259	foundDependency = true;
249	break;	260	break;
Lines 269-275 Link Here
269	return (IResource[]) modRes.toArray(new IResource[modRes.size()]);	280	return (IResource[]) modRes.toArray(new IResource[modRes.size()]);
270	}	281	}
271		282
272	/*	283	/**
273	* Finds the relative path to the file whose name matches of the given module. If no such file	284	* Finds the relative path to the file whose name matches of the given module. If no such file
274	* is found, the "Debug" folder is erased and an error is thrown.	285	* is found, the "Debug" folder is erased and an error is thrown.
275	*	286	*
Lines 280-286 Link Here
280	private IPath getModulePath(String topBuildDir, String moduleName, IResource[] resources, IProject project)	291	private IPath getModulePath(String topBuildDir, String moduleName, IResource[] resources, IProject project)
281	{	292	{
282	String fileNameContainingModule;	293	String fileNameContainingModule;
283	fileNameContainingModule = getFileNameContainingModule(moduleName, resources, topBuildDir);	294	fileNameContainingModule = getFileNameContainingModule(resources, moduleName);
284		295
285	//If we can't find any files with that module, remove Debug folder	296	//If we can't find any files with that module, remove Debug folder
286	if(fileNameContainingModule == null \|\| fileNameContainingModule == "") //$NON-NLS-1$	297	if(fileNameContainingModule == null \|\| fileNameContainingModule == "") //$NON-NLS-1$
Lines 301-379 Link Here
301	return p;	312	return p;
302	}	313	}
303		314
304	/*	315	/**
305	* This method operates under that assumption that	316	* This method finds the relative path to the filename that contains the
306	* 1. There will be no 2 files that are named the same, even if they are in separate folder	317	* name of the given module. It returns a string which is the relative
307	* 2. There is only 1 module per file	318	* path to the file containing the given module, with that
308	* 3. There are no files that differ in their names only by upper or lower case letters (i.e. file1.f90 and fILe1.f90)	319	* file's extension chopped off.
309	*	320	*
310	* This method finds the relative path to the filename that matches the name of the given module. It	321	* @moduleName - name of the module that we are retrieving the filename
311	* searches the list of given @resources to compare the names of contained files. It returns a string which
312	* is the relative path to the file supposedly containing the given module, with that file's extension chopped off.
313	*
314	* @moduleName - name of the module that we are comparing files against
315	* @resources - list of resources that we look through (could be files and folders)
316	*/	322	*/
317	private String getFileNameContainingModule(String moduleName, IResource[] resources, String buildDirName)	323	@SuppressWarnings("restriction")
		324	public String getFileNameContainingModule(IResource[] resources, String moduleName)
318	{	325	{
319	ArrayList possibleMatchingFiles = new ArrayList();	326	if(resources == null \|\| resources.length < 1 \|\|
320	if(resources == null \|\| resources.length < 1 \|\|	327	moduleName == null \|\| moduleName == "") //$NON-NLS-1$
321	moduleName == null \|\| moduleName == "") //$NON-NLS-1$	328	{
322	{	329	return null;
323	return null;	330	}
324	}	331	List<IFile> fileList = PhotranVPG.getInstance().findFilesThatExportModule(moduleName);
325		332
326	for(int i = 0; i < resources.length; i++)	333	return getFilePathFromResources(resources, fileList);
327	{
328	if(resources[i] instanceof IFile)
329	{
330	IFile f = (IFile)resources[i];
331
332	//Gets rid of the file extension
333	String fileName = f.getName().replaceFirst("\\..+", ""); //$NON-NLS-1$ //$NON-NLS-2$
334
335	//If a file name matches a module name exactly -- return the relative path to that file
336	if(fileName == moduleName)
337	return f.getProjectRelativePath().toString().replaceFirst("\\..+", ""); //$NON-NLS-1$ //$NON-NLS-2$
338
339	//Otherwise, check if the two names have different cases
340	else if(fileName.equalsIgnoreCase(moduleName))
341	{
342	//And if they do, keep it
343	possibleMatchingFiles.add(f.getProjectRelativePath().toString().replaceFirst("\\..+", "")); //$NON-NLS-1$ //$NON-NLS-2$
344	}
345	}
346	//If its a folder, recurse, but don't look in other build folders (Bug 326333)
347	else if(resources[i] instanceof IContainer && !resources[i].isDerived())
348	{
349	IContainer folder = (IContainer)resources[i];
350	IResource[] subResource = null;
351
352	//Skip build folder, because it contains files with the same
353	// names as the one we are looking for (created .o files)
354	if(folder.getName().equalsIgnoreCase(buildDirName))
355	continue;
356
357	try
358	{
359	subResource = folder.members();
360	}
361	catch (CoreException e)
362	{
363	throw new Error("Could not open a container to explore its files"); //$NON-NLS-1$
364	}
365
366	String name = getFileNameContainingModule(moduleName, subResource, buildDirName);
367	if(name != null)
368	return name;
369	}
370	}
371	if(possibleMatchingFiles.size() == 1)
372	return (String) possibleMatchingFiles.get(0);
373
374	return null;
375
376	}	334	}
		335
		336
		337	/**
		338	* Returns the file path of the file from file list that matches a
		339	* resource.
		340	*
		341	* @param resources: list of resources within the project
		342	* @param files: list of files
		343	*/
		344	private String getFilePathFromResources(IResource[] resources, List<IFile> files)
		345	{
		346	for(IFile file: files){
		347	for (IResource resource : resources){
		348	if (file.getProjectRelativePath().equals(resource.getProjectRelativePath())){
		349	return file.getProjectRelativePath().toString().replaceFirst("\\..+", ""); //$NON-NLS-1$ //$NON-NLS-2$
		350	}
		351	}
		352	}
		353	return null;
		354	}
377		355
378	private void removeDir(File f)	356	private void removeDir(File f)
379	{	357	{
Lines 395-401 Link Here
395	/* (non-Javadoc)	373	/* (non-Javadoc)
396	* @see org.eclipse.cdt.managedbuilder.makegen.IManagedBuilderDependencyCalculator#findDependencies(org.eclipse.core.resources.IResource)	374	* @see org.eclipse.cdt.managedbuilder.makegen.IManagedBuilderDependencyCalculator#findDependencies(org.eclipse.core.resources.IResource)
397	*/	375	*/
398	public IResource[] findDependencies(IResource resource, IProject project) {	376	@SuppressWarnings("restriction")
		377	public IResource[] findDependencies(IResource resource, IProject project) {
		378	boolean isRefactoringEnableForProject = PhotranVPG.getInstance().shouldProcessProject(project);
		379	if(!isRefactoringEnableForProject){
		380	forcePhotranVPGUpdate(project, true);
		381	}
		382
399	ArrayList dependencies = new ArrayList();	383	ArrayList dependencies = new ArrayList();
400	Collection fortranContentTypes = new FortranLanguage().getRegisteredContentTypeIds();	384	Collection fortranContentTypes = new FortranLanguage().getRegisteredContentTypeIds();
401		385
Lines 431-440 Link Here
431	{	415	{
432	return new IResource[0];	416	return new IResource[0];
433	}	417	}
		418	finally{
		419	if(!isRefactoringEnableForProject){
		420	PhotranVPG.getInstance().clearDatabase();
		421	forcePhotranVPGUpdate(project, false);
		422	}
		423	}
434		424
435	return (IResource[]) dependencies.toArray(new IResource[dependencies.size()]);	425	return (IResource[]) dependencies.toArray(new IResource[dependencies.size()]);
436	}	426	}
437		427
		428	/**
		429	* Force Photran VPG update and ensure the database is up-to-date
		430	*
		431	* @param project - Project to force VPG update on it
		432	* @param forceUpdate - whether force update
		433	*/
		434	@SuppressWarnings("restriction")
		435	private void forcePhotranVPGUpdate(IProject project, boolean forceUpdate){
		436	PhotranVPG.getInstance().setPropertyEnableVpg(project, forceUpdate);
		437	PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
		438	}
		439
438	/* (non-Javadoc)	440	/* (non-Javadoc)
439	* @see org.eclipse.cdt.managedbuilder.makegen.IManagedBuilderDependencyCalculator#getCalculatorType()	441	* @see org.eclipse.cdt.managedbuilder.makegen.IManagedBuilderDependencyCalculator#getCalculatorType()
440	*/	442	*/




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.cdtinterface.managebuilder;

import java.util.Arrays;

import org.eclipse.cdt.managedbuilder.core.IManagedIsToolChainSupported;
import org.eclipse.cdt.managedbuilder.core.IToolChain;
import org.osgi.framework.Version;

/**
 *  This class implements managed tool chain supported and outputs 
 *  whether Os, Compiler and tool chain are supported
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
 *        - Managed Build project, Fall CS 427
 */

public abstract class BaseManageBuilderToolChainSupported implements IManagedIsToolChainSupported
{
    private IPlatformOS platformOs = new PlatformOS();
    private ISupportedCompiler supportedCompiler = new CompilerSupported();
    
    /**
     * Sets mocked OS for unit testing
     * 
     * @param platformOs - Mock up OS to support testing.      
     */
    public void setPlatformOs(IPlatformOS platformOs)
    {
        this.platformOs = platformOs;
    }
    
    /**
     * Sets mocked compiler for unit testing
     * 
     * @param supportedCompiler - Mock up compiler to support testing.      
     */
    public void setCompilerSupported(ISupportedCompiler supportedCompiler)
    {
        this.supportedCompiler = supportedCompiler;
    }
    
    /**
     * @return <code>true</code> if the given tool-chain is supported on the system
     * otherwise returns <code>false</code>
     * 
     */
    public boolean isSupported(IToolChain toolChain, Version version, String instance)
    {
       return isOsSupported(toolChain) && isCompilerSupported();
    }
 
    protected abstract boolean isCompilerSupported();
    
    /**
     * @return <code>true</code> if the given OS in the tool-chain is supported on 
     * the system otherwise returns <code>false</code>
     *
     */
    private boolean isOsSupported(IToolChain toolChain)
    {
        return Arrays.asList(toolChain.getOSList()).contains(platformOs.getOS());
    }
    
    /**
     * @return <code>true</code> if the given compiler executable and version is 
     * supported on the system otherwise returns <code>false</code>
     *
     */
    protected boolean isCompilerSupported(String compilerExecutable, String versionFlag){
        return this.supportedCompiler.isSupported(compilerExecutable, versionFlag);
    }
}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/

package org.eclipse.photran.cdtinterface.managebuilder;

import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 *  This class implements supported compiler and outputs whether given compiler 
 *  is supported on the system.
 *  @author  Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *           Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
 *         - Managed Build project, Fall CS 427
 */

public class CompilerSupported implements ISupportedCompiler
{

    /**
     * @return <code>true</code> if the given compiler is supported on the system
     * otherwise returns <code>false</code>
     * 
     */
    @Override
    public boolean isSupported(String compilerExecutable, String versionFlag)
    {
        if(compilerExecutable == null || compilerExecutable == "") //$NON-NLS-1$
            throw new IllegalArgumentException("Invalid compilerExecutable argument"); //$NON-NLS-1$
        if(versionFlag == null || versionFlag == "") //$NON-NLS-1$
            throw new IllegalArgumentException("Invalid versionFlag argument"); //$NON-NLS-1$
        
        String[] command = new String[] {compilerExecutable, versionFlag};

        Process runCompilerCommand = null;
        boolean compilerSupported = false;
        try {
            runCompilerCommand = Runtime.getRuntime().exec(command);
            new BufferedReader(new InputStreamReader(
                runCompilerCommand.getInputStream()));            
            compilerSupported = true;
        } catch (Exception e) {
            System.out.println("Compiler doesn't exist " + e.getMessage()); //$NON-NLS-1$
        }
        finally{
            if(runCompilerCommand != null)
                runCompilerCommand.destroy();
        }
        return compilerSupported;
    }
}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.cdtinterface.managebuilder;
/**
 *  Interface to implement supported platform OS.
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
 *        - Managed Build project, Fall CS 427
 */
public interface IPlatformOS
{
    String getOS();
}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.cdtinterface.managebuilder;
/**
 *  Interface to implement supported compiler.
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan
 *        - Managed Build project, Fall CS 427
 */
public interface ISupportedCompiler
{
    public boolean isSupported(String compilerExecutable, String versionFlag);
}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.cdtinterface.managebuilder;

import org.eclipse.core.runtime.Platform;
/**
 *  This class implements platform OS and outputs Os, used only for unit testing
 *  to mock different operating systems.
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
 *        - Managed Build project, Fall CS 427
 */

public class PlatformOS implements IPlatformOS
{

    @Override
    public String getOS()
    {
        return Platform.getOS();
    }

}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.cdtinterface.managebuilder.gnu;

import org.eclipse.photran.cdtinterface.managebuilder.BaseManageBuilderToolChainSupported;
/**
 *  This class extends managed tool chain supported and outputs 
 *  whether Gnu fortran compiler is supported on the system.
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
 *        - Managed Build project, Fall CS 427
 */
public class IsGnuToolChainSupported  extends BaseManageBuilderToolChainSupported
{
    private static final String COMPILER_EXECUTABLE = "gfortran"; //$NON-NLS-1$
    private static final String VERSION_FLAG = "-dumpversion"; //$NON-NLS-1$ 
    
    /**
     * @return <code>true</code> if the gnu fortran compiler is supported on the system
     * otherwise returns <code>false</code>
     * 
     */
    @Override
    protected boolean isCompilerSupported()
    {
        return isCompilerSupported(COMPILER_EXECUTABLE,VERSION_FLAG);
    }
}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.cdtinterface.managebuilder.intel;

import org.eclipse.photran.cdtinterface.managebuilder.BaseManageBuilderToolChainSupported;
/**
 *  This class extends managed tool chain supported and outputs 
 *  whether Intel fortran compiler is supported on the system.
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan
 *        - Managed Build project, Fall CS 427
 */
public class IsIntelToolChainSupported  extends BaseManageBuilderToolChainSupported
{
    private static final String COMPILER_EXECUTABLE = "ifort"; //$NON-NLS-1$
    private static final String VERSION_FLAG = "-version"; //$NON-NLS-1$ 
    /**
     * @return <code>true</code> if the intel fortran compiler is supported on the system
     * otherwise returns <code>false</code>
     * 
     */
    @Override
    protected boolean isCompilerSupported()
    {
        return isCompilerSupported(COMPILER_EXECUTABLE, VERSION_FLAG);
    }
}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.cdtinterface.managebuilder.xlf;

import org.eclipse.photran.cdtinterface.managebuilder.BaseManageBuilderToolChainSupported;
/**
 *  This class extends managed tool chain supported and outputs 
 *  whether Xlf fortran compiler is supported on the system.
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan
 *        - Managed Build project, Fall CS 427
 */
public class IsXlfToolChainSupported extends BaseManageBuilderToolChainSupported
{
    private static final String COMPILER_EXECUTABLE = "xlf"; //$NON-NLS-1$
    private static final String VERSION_FLAG = "-qversion"; //$NON-NLS-1$    

    /**
     * @return <code>true</code> if the Xlf fortran compiler is supported on the system
     * otherwise returns <code>false</code>
     * 
     */
    @Override
    protected boolean isCompilerSupported()
    {
        return isCompilerSupported(COMPILER_EXECUTABLE, VERSION_FLAG);
    }
}

Lines 3-7 Link Here

(-)a/org.eclipse.photran.core.vpg.tests/.classpath (+1 lines)
3	<classpathentry kind="src" path="src"/>	3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>	4	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
5	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>	5	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
		6	<classpathentry combineaccessrules="false" kind="src" path="/org.eclipse.photran.cdtinterface"/>
6	<classpathentry kind="output" path="bin"/>	7	<classpathentry kind="output" path="bin"/>
7	</classpath>	8	</classpath>

Lines 17-23 Link Here

(-)a/org.eclipse.photran.core.vpg.tests/META-INF/MANIFEST.MF (-1 / +3 lines)
17	org.eclipse.rephraserengine.core,	17	org.eclipse.rephraserengine.core,
18	org.eclipse.rephraserengine.testing.junit3,	18	org.eclipse.rephraserengine.testing.junit3,
19	org.eclipse.rephraserengine.ui,	19	org.eclipse.rephraserengine.ui,
20	org.eclipse.photran.core	20	org.eclipse.photran.core,
		21	org.eclipse.photran.cdtinterface;bundle-version="8.0.0",
		22	org.eclipse.cdt.managedbuilder.core;bundle-version="8.1.0"
21	Bundle-ActivationPolicy: lazy	23	Bundle-ActivationPolicy: lazy
22	Bundle-Activator: org.eclipse.photran.internal.tests.Activator	24	Bundle-Activator: org.eclipse.photran.internal.tests.Activator
23	Export-Package: org.eclipse.photran.internal.tests;x-friends:="org.eclipse.photran.core.vpg.tests.failing,org.eclipse.photran.core.vpg.preprocessor.c.tests",	25	Export-Package: org.eclipse.photran.internal.tests;x-friends:="org.eclipse.photran.core.vpg.tests.failing,org.eclipse.photran.core.vpg.preprocessor.c.tests",




import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.IPDOMManager;
import org.eclipse.cdt.core.model.CoreModel;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.settings.model.CIncludePathEntry;
import org.eclipse.cdt.core.settings.model.ICConfigurationDescription;
import org.eclipse.cdt.core.settings.model.ICFolderDescription;
import org.eclipse.cdt.core.settings.model.ICLanguageSetting;
import org.eclipse.cdt.core.settings.model.ICLanguageSettingEntry;
import org.eclipse.cdt.core.settings.model.ICProjectDescription;
import org.eclipse.cdt.core.settings.model.ICSettingEntry;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;

 * @author Jeff Overbey - Modified so that every test case creates a new project - Added line/column
 *         computation when importing files - Added {@link #compileAndRunFortranProgram(String...)}
 *         Also added marker infrastructure.
 * @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *         Jose Alberto Lozano Hinojosa, Michael T O'Sullivan - Modified to 
 *         create test sub directories to avoid overwriting test file contents
 *         when file names are identical in sub directories.        
 */
public abstract class PhotranWorkspaceTestCase extends PhotranTestCase {


            PhotranVPG.getInstance().clearDatabase();
        }
        project = null;
    }

	// import file with test directory
    protected IFile importFile(String testSrcDir, String fileName, String contents) throws Exception
    {
        if(testSrcDir != null && testSrcDir != "")
        {
            IFolder folder = project.getProject().getFolder(testSrcDir);
            if(!folder.exists())
                  folder.create(true, false, monitor);
            fileName = "/" + testSrcDir + "/" + fileName;
        }        
        return importFile(fileName, contents);
    }
    
    protected IFile importFile(String fileName, String contents) throws Exception
    {
		//Obtain file handle

        return result;
    }

    protected IFile importFile(Plugin activator, String srcDir, String filename, String testSrcDir) throws Exception
    {
        //project.getProject().getFile(filename).delete(true, new NullProgressMonitor());
        IFile result = importFile(testSrcDir, filename, readTestFile(activator, srcDir, filename));
        //project.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
        return result;
    }
    
    protected String readTestFile(Plugin activator, String srcDir, String filename) throws IOException, URISyntaxException
    {
        ArrayList<Integer> lineMap = new ArrayList<Integer>(50);




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.internal.tests.managed.build;

import org.eclipse.cdt.managedbuilder.core.IToolChain;
import org.eclipse.photran.cdtinterface.managebuilder.BaseManageBuilderToolChainSupported;
import org.eclipse.photran.cdtinterface.managebuilder.CompilerSupported;
import org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported;
import org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported;
import org.eclipse.photran.cdtinterface.managebuilder.xlf.IsXlfToolChainSupported;
import org.eclipse.photran.internal.tests.PhotranWorkspaceTestCase;
/**
 *  Unit test class for testing supported platform OS and compilers for a given 
 *  project type and tool chain in new fortran project wizard. Use PhotranVPG 
 *  to find dependencies for the given project. 
 *  
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan
 *          (Managed Build project, Fall CS 427)
 */

public class IsToolChainSupportedTest extends PhotranWorkspaceTestCase
{
    //Test win32 and gnu fortran compiler are supported, other OSes are unsupported.
    public void testOsWindowsAndGnuIsSupported() throws Exception
    {
        BaseManageBuilderToolChainSupported toolChainSupported = new IsGnuToolChainSupported();
        osAndAndCompilerIsSupported(toolChainSupported,"win32", new String[] {"solaris", "linux", "hpux", "aix", "qnx", "macosx"}, "gfortran", "-dumpversion");
    }
    
    //Test macosx and gnu fortran compiler are supported, other OSes are unsupported.
    public void testOsMacOsXAndGnuIsSupported() throws Exception
    {
        BaseManageBuilderToolChainSupported toolChainSupported = new IsGnuToolChainSupported();
        osAndAndCompilerIsSupported(toolChainSupported,"macosx", new String[] {"solaris", "linux", "hpux", "aix", "qnx", "win32"}, "gfortran", "-dumpversion");
    }
    
    //Test linux and gnu fortran compiler are supported, other OSes are unsupported.
    public void testOsLinuxAndGnuIsSupported() throws Exception
    {
        BaseManageBuilderToolChainSupported toolChainSupported = new IsGnuToolChainSupported();
        osAndAndCompilerIsSupported(toolChainSupported, "linux", new String[] {"win32", "macosx"}, "gfortran", "-dumpversion");
    }
    
    //Test win32 and intel fortran compiler are supported, other OSes are unsupported.
    public void testOsWindowsAndIntelIsSupported() throws Exception
    {
        BaseManageBuilderToolChainSupported toolChainSupported = new IsIntelToolChainSupported();
        osAndAndCompilerIsSupported(toolChainSupported, "win32", new String[] {"solaris", "linux", "hpux", "aix", "qnx", "macosx"}, "ifort", "-version");
    }
    
    //Test macosx and intel fortran compiler are supported, other OSes are unsupported.
    public void testOsMacOsXAndIntelIsSupported() throws Exception
    {
        BaseManageBuilderToolChainSupported toolChainSupported = new IsIntelToolChainSupported();
        osAndAndCompilerIsSupported(toolChainSupported, "macosx", new String[] {"solaris", "linux", "hpux", "aix", "qnx", "win32"}, "ifort", "-version");
    }
    
    //Test linux and intel fortran compiler are supported, other OSes are unsupported.
    public void testOsLinuxAndAndIntelIsSupported() throws Exception
    {
        BaseManageBuilderToolChainSupported toolChainSupported = new IsIntelToolChainSupported();
        osAndAndCompilerIsSupported(toolChainSupported, "linux", new String[] {"win32", "macosx"}, "ifort", "-version");
    }
    
    //Test win32 and xlf fortran compiler are supported, other OSes are unsupported.
    public void testOsWindowsAndXlfIsSupported() throws Exception
    {
        BaseManageBuilderToolChainSupported toolChainSupported = new IsXlfToolChainSupported();
        osAndAndCompilerIsSupported(toolChainSupported, "win32", new String[] {"solaris", "linux", "hpux", "aix", "qnx", "macosx"}, "xlf", "-qversion");
    }
    
    //Test macosx and xlf fortran compiler are supported, other OSes are unsupported.
    public void testOsMacOsXAndXlfIsSupported() throws Exception
    {
        BaseManageBuilderToolChainSupported toolChainSupported = new IsXlfToolChainSupported();
        osAndAndCompilerIsSupported(toolChainSupported,"macosx", new String[] {"solaris", "linux", "hpux", "aix", "qnx", "win32"}, "xlf", "-qversion");
    }
    
    //Test linux and xlf fortran compiler are supported, other OSes are unsupported.
    public void testOsLinuxAndAndXlfIsSupported() throws Exception
    {
        BaseManageBuilderToolChainSupported toolChainSupported = new IsXlfToolChainSupported();
        osAndAndCompilerIsSupported(toolChainSupported, "linux", new String[] {"win32", "macosx"}, "xlf", "-qversion");
    }
    
    //Test input validation for empty compiler executable
    public void testEmptyCompilerExecutable() throws Exception
    {
        try
        {            
            CompilerSupported compilerSupported = new CompilerSupported();
            compilerSupported.isSupported("", "-qversion");
        }
        catch(IllegalArgumentException e)
        {
            return;
        }
        fail("testEmptyCompilerExecutable failed to throw exception");
    }
    
    //Test input validation for null compiler executable
    public void testNullCompilerExecutable() throws Exception
    {
        try
        {
            CompilerSupported compilerSupported = new CompilerSupported();
            compilerSupported.isSupported(null, "-qversion");
        }
        catch(IllegalArgumentException e)
        {
            return;
        }
        fail("testNullCompilerExecutable failed to throw exception");
    }
    
    //Test input validation for empty version flag
    public void testEmptyCompilerFlag() throws Exception
    {
        try
        {
            CompilerSupported compilerSupported = new CompilerSupported();
            compilerSupported.isSupported("xlf", "");            
        }
        catch(IllegalArgumentException e)
        {
            return;
        }
        fail("testEmptyCompilerFlag failed to throw exception");
    }
    
    //Test input validation for null version flag
    public void testNullCompilerFlag() throws Exception
    {
        try
        {
            CompilerSupported compilerSupported = new CompilerSupported();
            compilerSupported.isSupported("xlf", null);
        }
        catch(IllegalArgumentException e)
        {
            return;
        }
        fail("testNullCompilerFlag failed to throw exception");
    }
    
    //Test catch block with invalid executable
    public void testInvalidCompilerCommand() throws Exception
    {
        CompilerSupported compilerSupported = new CompilerSupported();
        assertFalse(compilerSupported.isSupported("invalidCompiler", "-version"));
    }
    

    //Test at least one OS and one fortran compiler is supported
    public void testOneOsAndOneCompilerIsSupported() throws Exception
    {
        boolean hasAtLeastOneToolChainSupport = false;
        
        IToolChain supportedOs = new MockToolChain();
        supportedOs.setOSList(new String[] {"win32","macosx","solaris", "linux", "hpux", "aix", "qnx"});
        
        BaseManageBuilderToolChainSupported toolChainSupported = new IsGnuToolChainSupported();
        
        hasAtLeastOneToolChainSupport = toolChainSupported.isSupported(supportedOs, null, null);
        
        if (!hasAtLeastOneToolChainSupport) {
            toolChainSupported = new IsIntelToolChainSupported();
            hasAtLeastOneToolChainSupport = toolChainSupported.isSupported(supportedOs, null, null);
        }
        
        if (!hasAtLeastOneToolChainSupport) {
            toolChainSupported = new IsXlfToolChainSupported();
            hasAtLeastOneToolChainSupport = toolChainSupported.isSupported(supportedOs, null, null);
        }
        
        assertTrue(hasAtLeastOneToolChainSupport);
    }
    
    // Helper function to set mock tool chain and test whether OS and compiler are supported.
    private void osAndAndCompilerIsSupported(BaseManageBuilderToolChainSupported toolChainSupported, String supportedOsString, String[] unsupportedOsString, String compiler, String versionFlag)
    {
        toolChainSupported.setPlatformOs(new MockPlatformOS(supportedOsString));
        toolChainSupported.setCompilerSupported(new MockSupportedCompiler(compiler, versionFlag));
        IToolChain supportedOs = new MockToolChain();
        supportedOs.setOSList(new String[] {supportedOsString});
        assertTrue(toolChainSupported.isSupported(supportedOs, null, null));
        IToolChain unsupportedOs = new MockToolChain();
        unsupportedOs.setOSList(unsupportedOsString);
        assertFalse(toolChainSupported.isSupported(unsupportedOs, null, null));
    }

}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.internal.tests.managed.build;

import org.eclipse.photran.cdtinterface.managebuilder.IPlatformOS;
/**
 *  This class implements platform OS supported and outputs mocked OS.
 *  
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
 *          (Managed Build project, Fall CS427)
 */
public class MockPlatformOS implements IPlatformOS
{
    private String os;

    public MockPlatformOS(String os)
    {
        this.os = os;
    }
   
    @Override
    public String getOS()
    {
        return os;
    }

}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.internal.tests.managed.build;

import org.eclipse.photran.cdtinterface.managebuilder.ISupportedCompiler;

/**
 *  This class implements supported compiler and outputs result
 *  based on mocked compiler executable and version flag.
 *  
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
 *          (Managed Build project, Fall CS427)
 */
public class MockSupportedCompiler implements ISupportedCompiler 
{
    private String compilerExecutable;
    private String versionFlag;
    public MockSupportedCompiler(String compilerExecutable, String versionFlag){
       this.compilerExecutable = compilerExecutable;
       this.versionFlag = versionFlag;     
    }

    @Override
    public boolean isSupported(String compilerExecutable, String versionFlag)
    {
        return this.compilerExecutable.equals(compilerExecutable) && this.versionFlag.equals(versionFlag);
    }
}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.internal.tests.managed.build;

import org.eclipse.cdt.core.settings.model.extension.CTargetPlatformData;
import org.eclipse.cdt.managedbuilder.core.BuildException;
import org.eclipse.cdt.managedbuilder.core.IBuilder;
import org.eclipse.cdt.managedbuilder.core.IConfiguration;
import org.eclipse.cdt.managedbuilder.core.IFolderInfo;
import org.eclipse.cdt.managedbuilder.core.IHoldsOptions;
import org.eclipse.cdt.managedbuilder.core.IOption;
import org.eclipse.cdt.managedbuilder.core.IOptionCategory;
import org.eclipse.cdt.managedbuilder.core.IOptionPathConverter;
import org.eclipse.cdt.managedbuilder.core.IOutputType;
import org.eclipse.cdt.managedbuilder.core.ITargetPlatform;
import org.eclipse.cdt.managedbuilder.core.ITool;
import org.eclipse.cdt.managedbuilder.core.IToolChain;
import org.eclipse.cdt.managedbuilder.envvar.IConfigurationEnvironmentVariableSupplier;
import org.eclipse.cdt.managedbuilder.macros.IConfigurationBuildMacroSupplier;
import org.osgi.framework.Version;
/**
 *  This class implements tool chain and outputs mocked tool chain.
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
 *          (Managed Build project, Fall CS427)
 */

public class MockToolChain implements IToolChain
{

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IBuildObject#getId()
     */
    @Override
    public String getId()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IBuildObject#getName()
     */
    @Override
    public String getName()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IBuildObject#getBaseId()
     */
    @Override
    public String getBaseId()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IBuildObject#getVersion()
     */
    @Override
    public Version getVersion()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IBuildObject#setVersion(org.osgi.framework.Version)
     */
    @Override
    public void setVersion(Version version)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IBuildObject#getManagedBuildRevision()
     */
    @Override
    public String getManagedBuildRevision()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#createOption(org.eclipse.cdt.managedbuilder.core.IOption, java.lang.String, java.lang.String, boolean)
     */
    @Override
    public IOption createOption(IOption superClass, String Id, String name,
        boolean isExtensionElement)
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#removeOption(org.eclipse.cdt.managedbuilder.core.IOption)
     */
    @Override
    public void removeOption(IOption option)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#getOption(java.lang.String)
     */
    @Override
    @Deprecated
    public IOption getOption(String id)
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#getOptionById(java.lang.String)
     */
    @Override
    public IOption getOptionById(String id)
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#getOptionBySuperClassId(java.lang.String)
     */
    @Override
    public IOption getOptionBySuperClassId(String id)
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#getOptions()
     */
    @Override
    public IOption[] getOptions()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#getChildCategories()
     */
    @Override
    public IOptionCategory[] getChildCategories()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#addOptionCategory(org.eclipse.cdt.managedbuilder.core.IOptionCategory)
     */
    @Override
    public void addOptionCategory(IOptionCategory category)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#getOptionCategory(java.lang.String)
     */
    @Override
    public IOptionCategory getOptionCategory(String id)
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#createOptions(org.eclipse.cdt.managedbuilder.core.IHoldsOptions)
     */
    @Override
    public void createOptions(IHoldsOptions superClass)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#getOptionToSet(org.eclipse.cdt.managedbuilder.core.IOption, boolean)
     */
    @Override
    public IOption getOptionToSet(IOption option, boolean adjustExtension) throws BuildException
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#needsRebuild()
     */
    @Override
    public boolean needsRebuild()
    {
        // TODO Auto-generated method stub
        return false;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IHoldsOptions#setRebuildState(boolean)
     */
    @Override
    public void setRebuildState(boolean rebuild)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getParent()
     */
    @Override
    public IConfiguration getParent()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#createTargetPlatform(org.eclipse.cdt.managedbuilder.core.ITargetPlatform, java.lang.String, java.lang.String, boolean)
     */
    @Override
    public ITargetPlatform createTargetPlatform(ITargetPlatform superClass, String Id, String name,
        boolean isExtensionElement)
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getTargetPlatform()
     */
    @Override
    public ITargetPlatform getTargetPlatform()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#removeLocalTargetPlatform()
     */
    @Override
    public void removeLocalTargetPlatform()
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getVersionsSupported()
     */
    @Override
    public String getVersionsSupported()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getConvertToId()
     */
    @Override
    public String getConvertToId()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#setVersionsSupported(java.lang.String)
     */
    @Override
    public void setVersionsSupported(String versionsSupported)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#setConvertToId(java.lang.String)
     */
    @Override
    public void setConvertToId(String convertToId)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#createBuilder(org.eclipse.cdt.managedbuilder.core.IBuilder, java.lang.String, java.lang.String, boolean)
     */
    @Override
    public IBuilder createBuilder(IBuilder superClass, String Id, String name,
        boolean isExtensionElement)
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#removeLocalBuilder()
     */
    @Override
    public void removeLocalBuilder()
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getBuilder()
     */
    @Override
    public IBuilder getBuilder()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#createTool(org.eclipse.cdt.managedbuilder.core.ITool, java.lang.String, java.lang.String, boolean)
     */
    @Override
    public ITool createTool(ITool superClass, String Id, String name, boolean isExtensionElement)
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getTools()
     */
    @Override
    public ITool[] getTools()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getTool(java.lang.String)
     */
    @Override
    public ITool getTool(String id)
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getToolsBySuperClassId(java.lang.String)
     */
    @Override
    public ITool[] getToolsBySuperClassId(String id)
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getSuperClass()
     */
    @Override
    public IToolChain getSuperClass()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#isAbstract()
     */
    @Override
    public boolean isAbstract()
    {
        // TODO Auto-generated method stub
        return false;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#setIsAbstract(boolean)
     */
    @Override
    public void setIsAbstract(boolean b)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getUnusedChildren()
     */
    @Override
    public String getUnusedChildren()
    {
        // TODO Auto-generated method stub
        return null;
    }

    private String[] osList; 
    
    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getOSList()
     */
    @Override
    public String[] getOSList()
    {
        return osList;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#setOSList(java.lang.String[])
     */
    @Override
    public void setOSList(String[] OSs)
    {
        osList = OSs;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getArchList()
     */
    @Override
    public String[] getArchList()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#setArchList(java.lang.String[])
     */
    @Override
    public void setArchList(String[] archs)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getErrorParserIds()
     */
    @Override
    public String getErrorParserIds()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getErrorParserIds(org.eclipse.cdt.managedbuilder.core.IConfiguration)
     */
    @Override
    public String getErrorParserIds(IConfiguration config)
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getErrorParserList()
     */
    @Override
    public String[] getErrorParserList()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#setErrorParserIds(java.lang.String)
     */
    @Override
    public void setErrorParserIds(String ids)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getDefaultLanguageSettingsProviderIds()
     */
    @Override
    public String getDefaultLanguageSettingsProviderIds()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getScannerConfigDiscoveryProfileId()
     */
    @Override
    public String getScannerConfigDiscoveryProfileId()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#setScannerConfigDiscoveryProfileId(java.lang.String)
     */
    @Override
    public void setScannerConfigDiscoveryProfileId(String profileId)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getTargetToolIds()
     */
    @Override
    public String getTargetToolIds()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#setTargetToolIds(java.lang.String)
     */
    @Override
    public void setTargetToolIds(String targetToolIds)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getTargetToolList()
     */
    @Override
    public String[] getTargetToolList()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getSecondaryOutputs()
     */
    @Override
    public IOutputType[] getSecondaryOutputs()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#setSecondaryOutputs(java.lang.String)
     */
    @Override
    public void setSecondaryOutputs(String ids)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#isDirty()
     */
    @Override
    public boolean isDirty()
    {
        // TODO Auto-generated method stub
        return false;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#setDirty(boolean)
     */
    @Override
    public void setDirty(boolean isDirty)
    {
        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#isExtensionElement()
     */
    @Override
    public boolean isExtensionElement()
    {
        // TODO Auto-generated method stub
        return false;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#isSupported()
     */
    @Override
    public boolean isSupported()
    {
        // TODO Auto-generated method stub
        return false;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getEnvironmentVariableSupplier()
     */
    @Override
    public IConfigurationEnvironmentVariableSupplier getEnvironmentVariableSupplier()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getBuildMacroSupplier()
     */
    @Override
    public IConfigurationBuildMacroSupplier getBuildMacroSupplier()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getOptionPathConverter()
     */
    @Override
    public IOptionPathConverter getOptionPathConverter()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getParentFolderInfo()
     */
    @Override
    public IFolderInfo getParentFolderInfo()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getTargetPlatformData()
     */
    @Override
    public CTargetPlatformData getTargetPlatformData()
    {
        // TODO Auto-generated method stub
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#supportsBuild(boolean)
     */
    @Override
    public boolean supportsBuild(boolean managed)
    {
        // TODO Auto-generated method stub
        return false;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#isSystemObject()
     */
    @Override
    public boolean isSystemObject()
    {
        // TODO Auto-generated method stub
        return false;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#matches(org.eclipse.cdt.managedbuilder.core.IToolChain)
     */
    @Override
    public boolean matches(IToolChain tc)
    {
        // TODO Auto-generated method stub
        return false;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.managedbuilder.core.IToolChain#getUniqueRealName()
     */
    @Override
    public String getUniqueRealName()
    {
        // TODO Auto-generated method stub
        return null;
    }

}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/
package org.eclipse.photran.internal.tests.managed.build;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.photran.cdtinterface.makegen.DefaultFortranDependencyCalculator;
import org.eclipse.photran.internal.core.properties.SearchPathProperties;
import org.eclipse.photran.internal.core.vpg.PhotranVPG;
import org.eclipse.photran.internal.tests.Activator;
import org.eclipse.photran.internal.tests.PhotranWorkspaceTestCase;
/**
 *  Unit test class for testing module name dependency on file name using 
 *  PhotranVPG.
 *  
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
 *          (Managed Build project, Fall CS427)
 */

public class ModuleNameDifferentTest extends PhotranWorkspaceTestCase
{
    private static final String DIR = "vpg-test-code/managed-build/module-name-different/";
    
    // Test module name matches file name
    public void testModuleMatchFile() throws Exception
    {
        String DIR_test = DIR + "test1";
        IResource[] resources = new IResource[1];
        IFile module1 = importFile(Activator.getDefault(), DIR_test, "module1.f90");
        PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
        resources[0] = module1;

        DefaultFortranDependencyCalculator calculator = new DefaultFortranDependencyCalculator();
        String fileName = calculator.getFileNameContainingModule(resources, "module1");
        assertEquals("module1", fileName);
    }

    // Test module name does not match file name
    public void testModuleNotMatchFile() throws Exception
    {        
        String DIR_test = DIR + "test2";
        IResource[] resources = new IResource[1];
        IFile module1 = importFile(Activator.getDefault(), DIR_test, "modules.f90");
        PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
        resources[0] = module1;

        DefaultFortranDependencyCalculator calculator = new DefaultFortranDependencyCalculator();
        String fileName = calculator.getFileNameContainingModule(resources, "module1");
        assertEquals("modules", fileName);
     }

    // Test module name does not exist in the file 
    public void testNonexistentModuleName() throws Exception
    {        
        String DIR_test = DIR + "test3";
        IResource[] resources = new IResource[1];
        IFile module1 = importFile(Activator.getDefault(), DIR_test, "modules.f90");
        PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
        resources[0] = module1;

        DefaultFortranDependencyCalculator calculator = new DefaultFortranDependencyCalculator();
        String fileName = calculator.getFileNameContainingModule(resources, "nonexistentModule");
        assertNull(fileName);
     }
    
    // Test empty module name
    public void testEmptyModuleName() throws Exception
    {        
        String DIR_test = DIR + "test3";
        IResource[] resources = new IResource[1];
        IFile module1 = importFile(Activator.getDefault(), DIR_test, "modules.f90");
        PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
        resources[0] = module1;

        DefaultFortranDependencyCalculator calculator = new DefaultFortranDependencyCalculator();
        String fileName = calculator.getFileNameContainingModule(resources, "");
        assertNull(fileName);
     }
    
    // Test null module name
    public void testNullModuleName() throws Exception
    {        
        String DIR_test = DIR + "test3";
        IResource[] resources = new IResource[1];
        IFile module1 = importFile(Activator.getDefault(), DIR_test, "modules.f90");
        PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
        resources[0] = module1;

        DefaultFortranDependencyCalculator calculator = new DefaultFortranDependencyCalculator();
        String fileName = calculator.getFileNameContainingModule(resources, null);
        assertNull(fileName);
     }
    
    // Test empty resources 
    public void testEmptyResources() throws Exception
    {        
        IResource[] resources = new IResource[0];
        DefaultFortranDependencyCalculator calculator = new DefaultFortranDependencyCalculator();
        String fileName = calculator.getFileNameContainingModule(resources, "module1");
        assertNull(fileName);
     }
    
    // Test null resources
    public void testNullResources() throws Exception
    {        
        IResource[] resources = null;
        DefaultFortranDependencyCalculator calculator = new DefaultFortranDependencyCalculator();
        String fileName = calculator.getFileNameContainingModule(resources, "module1");
        assertNull(fileName);
    }

    // Test set analysis/refactoring enable
    public void testSetPropertyEnableVpg() throws Exception
    {   
        // initial setting is false
        String vpgDisableProperty = new SearchPathProperties().getProperty(project, SearchPathProperties.ENABLE_VPG_PROPERTY_NAME);
        assertFalse(vpgDisableProperty.equals("false"));
        
        // set it to true
        PhotranVPG.getInstance().setPropertyEnableVpg(project, true);
        String vpgEnabledProperty = new SearchPathProperties().getProperty(project, SearchPathProperties.ENABLE_VPG_PROPERTY_NAME);
        assertTrue(vpgEnabledProperty.equals("true"));
        
        // set it back to false
        PhotranVPG.getInstance().setPropertyEnableVpg(project, false);
        vpgDisableProperty  = new SearchPathProperties().getProperty(project, SearchPathProperties.ENABLE_VPG_PROPERTY_NAME);
        assertTrue(vpgDisableProperty.equals("false"));
    }
}




/*******************************************************************************
* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 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:
* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
*      - Initial API and implementation
*******************************************************************************/

package org.eclipse.photran.internal.tests.managed.build;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.photran.cdtinterface.makegen.DefaultFortranDependencyCalculator;
import org.eclipse.photran.internal.core.vpg.PhotranVPG;
import org.eclipse.photran.internal.tests.Activator;
import org.eclipse.photran.internal.tests.PhotranWorkspaceTestCase;
/**
 *  Unit test class for testing multiple modules and files using PhotranVPG.
 *  
 *  @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
 *          Jose Alberto Lozano Hinojosa, Michael T O'Sullivan 
 *          (Managed Build project, Fall CS427)
 */
public class MulitpleModuleInFileTest extends PhotranWorkspaceTestCase
{
    private static final String DIR = "vpg-test-code/managed-build/multiple-module-in-file/";
    
    // Test for multiple modules in a single file, and main program 
    // has same order on how modules are defined in the source file
    public void testMultipleModulesInOrder() throws Exception
    {
        String DIR_test = DIR + "testMultipleModulesInOrder";
        IResource[] resources = new IResource[2];
        IFile main = importFile(Activator.getDefault(), DIR_test, "main.f90");
        IFile module1 = importFile(Activator.getDefault(), DIR_test, "modules.f90");
        PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
        resources[0] = main;
        resources[1] = module1;

        DefaultFortranDependencyCalculator calculator = new DefaultFortranDependencyCalculator();
        String fileName = calculator.getFileNameContainingModule(resources, "module1");
        assertEquals("modules", fileName);
        
        fileName = calculator.getFileNameContainingModule(resources, "module2");
        assertEquals("modules", fileName);
    }

    // Test for multiple modules in a single file, and main program 
    // has different order on how modules are defined in the source file
    public void testMultipleModulesNotInOrder() throws Exception
    {
        String DIR_test = DIR + "testMultipleModulesNotInOrder";
        IResource[] resources = new IResource[2];
        IFile main = importFile(Activator.getDefault(), DIR_test, "main.f90");
        IFile modules = importFile(Activator.getDefault(), DIR_test, "modules.f90");
        PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
        resources[0] = main;
        resources[1] = modules;

        DefaultFortranDependencyCalculator calculator = new DefaultFortranDependencyCalculator();
        String fileName = calculator.getFileNameContainingModule(resources, "module1");
        assertEquals("modules", fileName);
        
        fileName = calculator.getFileNameContainingModule(resources, "module2");
        assertEquals("modules", fileName);
    }

    // Test different module in same file name and different folder
    public void testDifferentFoldersIdenticalFilesContainsUniqueModule() throws Exception
    {   
        String DIR_test = DIR + "testDifferentFoldersIdenticalFilesContainsUniqueModule/";
        String DIR_folder1_test = DIR_test + "folder1";
        String DIR_folder2_test = DIR_test + "folder2";
        IResource[] resources = new IResource[2];
        IFile module1 = importFile(Activator.getDefault(), DIR_folder1_test, "modules.f90", "folder1");
        IFile module2 = importFile(Activator.getDefault(), DIR_folder2_test, "modules.f90", "folder2");
        PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
        
        resources[0] = module1;
        resources[1] = module2;

        DefaultFortranDependencyCalculator calculator = new DefaultFortranDependencyCalculator();
        
        String fileNameModule1 = calculator.getFileNameContainingModule(resources, "module1");
        assertEquals("folder1/modules", fileNameModule1);
        
        String fileNameModule2 = calculator.getFileNameContainingModule(resources, "module2");
        assertEquals("folder2/modules", fileNameModule2);
     }
    
    // Test different module in same file name and different folder
    public void testDifferentFoldersIdenticalFilesContainsUniqueModuleDifferentProjects() throws Exception
    {   
        String DIR_test = DIR + "testDifferentFoldersIdenticalFilesContainsUniqueModuleDifferentProjects/";
        String DIR_project2_folder1_test = DIR_test + "project2/folder1";
        IResource[] resources = new IResource[1];
        IFile project2_module1 = importFile(Activator.getDefault(), DIR_project2_folder1_test, "modules.f90", "folder1");
        PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
        
        resources[0] = project2_module1;

        DefaultFortranDependencyCalculator calculator = new DefaultFortranDependencyCalculator();
        
        String fileNameModule1 = calculator.getFileNameContainingModule(resources, "module1");
        assertEquals("folder1/modules", fileNameModule1);
     }
}

Added Link Here

(-)a/org.eclipse.photran.core.vpg.tests/vpg-test-code/managed-build/module-name-different/test1/module1.f90 (+2 lines)
1	module module1
2	end module module1

Added Link Here

(-)a/org.eclipse.photran.core.vpg.tests/vpg-test-code/managed-build/module-name-different/test2/modules.f90 (+2 lines)
1	module module1
2	end module module1

Added Link Here

(-)a/org.eclipse.photran.core.vpg.tests/vpg-test-code/managed-build/module-name-different/test3/modules.f90 (+2 lines)
1	module module1
2	end module module1

Added Link Here

(-)a/org.eclipse.photran.core.vpg.tests/vpg-test-code/managed-build/multiple-module-in-file/testDifferentFoldersIdenticalFilesContainsUniqueModule/folder1/modules.f90 (+2 lines)
1	module module1
2	end module module1

Added Link Here

(-)a/org.eclipse.photran.core.vpg.tests/vpg-test-code/managed-build/multiple-module-in-file/testDifferentFoldersIdenticalFilesContainsUniqueModule/folder2/modules.f90 (+2 lines)
1	module module2
2	end module module2

Added Link Here

(-)a/org.eclipse.photran.core.vpg.tests/vpg-test-code/managed-build/multiple-module-in-file/testDifferentFoldersIdenticalFilesContainsUniqueModuleDifferentProjects/project1/modules.f90 (+2 lines)
1	module module1
2	end module module1

Added Link Here

(-)a/org.eclipse.photran.core.vpg.tests/vpg-test-code/managed-build/multiple-module-in-file/testDifferentFoldersIdenticalFilesContainsUniqueModuleDifferentProjects/project2/folder1/modules.f90 (+2 lines)
1	module module1
2	end module module1

Added Link Here

(-)a/org.eclipse.photran.core.vpg.tests/vpg-test-code/managed-build/multiple-module-in-file/testMultipleModulesInOrder/main.f90 (+4 lines)
1	program main
2	USE Module1
3	USE Module2
4	end program

Added Link Here

(-)a/org.eclipse.photran.core.vpg.tests/vpg-test-code/managed-build/multiple-module-in-file/testMultipleModulesInOrder/modules.f90 (+5 lines)
1	module module1
2	end module module1
3
4	module module2
5	end module module2

Added Link Here

(-)a/org.eclipse.photran.core.vpg.tests/vpg-test-code/managed-build/multiple-module-in-file/testMultipleModulesNotInOrder/main.f90 (+4 lines)
1	program main
2	USE Module2
3	USE Module1
4	end program

Added Link Here

(-)a/org.eclipse.photran.core.vpg.tests/vpg-test-code/managed-build/multiple-module-in-file/testMultipleModulesNotInOrder/modules.f90 (+5 lines)
1	module module1
2	end module module1
3
4	module module2
5	end module module2

Lines 39-44 Link Here

(-)a/org.eclipse.photran.core.vpg/src/org/eclipse/photran/internal/core/vpg/PhotranVPG.java (+18 lines)
39	* Photran's Virtual Program Graph.	39	* Photran's Virtual Program Graph.
40	*	40	*
41	* @author Jeff Overbey	41	* @author Jeff Overbey
		42	* @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
		43	* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan
		44	* -- Added setPropertyEnableVpg function to programmatically set Enable
		45	* VPG property (Managed Build project, Fall CS 427)
42	*/	46	*/
43	//public class PhotranVPG extends EclipseVPG<IFortranAST, Token, PhotranTokenRef, PhotranVPGDB, PhotranVPGLog>	47	//public class PhotranVPG extends EclipseVPG<IFortranAST, Token, PhotranTokenRef, PhotranVPGDB, PhotranVPGLog>
44	public class PhotranVPG extends EclipseVPG<IFortranAST, Token, PhotranTokenRef>	48	public class PhotranVPG extends EclipseVPG<IFortranAST, Token, PhotranTokenRef>
Lines 544-549 Link Here
544	return false; // Project may be closed, or something like that; see Bug 369094	548	return false; // Project may be closed, or something like that; see Bug 369094
545	}	549	}
546	}	550	}
		551
		552	/**
		553	* Set the ENABLE_VPG_PROPERTY_NAME property for a given project
		554	*
		555	* @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
		556	* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan
		557	*
		558	* @param project - Project to set its ENABLE_VPG_PROPERTY_NAME property
		559	* @param value - property value to set
		560	*/
		561	public void setPropertyEnableVpg(IProject project, boolean value)
		562	{
		563	new SearchPathProperties().setProperty(project, SearchPathProperties.ENABLE_VPG_PROPERTY_NAME, Boolean.toString(value));
		564	}
547		565
548	public String describeWhyCannotProcessProject(IProject project)	566	public String describeWhyCannotProcessProject(IProject project)
549	{	567	{




                     name="%ToolChainName.Dbg"
                     targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.debug"
                     scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
                     id="photran.managedbuild.toolchain.gnu.fortran.exe.debug"
                     isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
		          <targetPlatform
		              id="photran.managedbuild.target.gnu.platform.exe.debug"
		              name="%PlatformName.Dbg"

                     name="%ToolChainName.Rel"
                     targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.release"
                     scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
                     id="photran.managedbuild.toolchain.gnu.fortran.exe.release"
                     isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
		          <targetPlatform
		              id="photran.managedbuild.target.gnu.platform.fortran.exe.release"
		              name="%PlatformName.Rel"

                     name="%ToolChainName.Dbg"
                     targetTool="photran.managedbuild.tool.macosx.fortran.linker.macosx.exe.debug"
                     scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
                     id="photran.managedbuild.toolchain.gnu.fortran.macosx.exe.debug"
                     isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
                  <targetPlatform
					  id="photran.managedbuild.target.gnu.platform.macosx.exe.debug"
				 	  name="%PlatformName.Dbg"

                     name="%ToolChainName.Rel"
                     targetTool="photran.managedbuild.tool.macosx.fortran.linker.macosx.exe.release"
                     scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
                     id="photran.managedbuild.toolchain.gnu.fortran.macosx.exe.release"
                     isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
                  <targetPlatform
					  id="photran.managedbuild.target.gnu.platform.fortran.macosx.exe.release"
				 	  name="%PlatformName.Rel"

                     name="%ToolChainName.Dbg"
                     targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.debug"
                     scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
                     id="photran.managedbuild.toolchain.gnu.fortran.win32.exe.debug"
                     isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
                  <targetPlatform
					  id="photran.managedbuild.target.gnu.platform.win32.exe.debug"
				 	  name="%PlatformName.Dbg"

                     name="%ToolChainName.Rel"
                     targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.release"
                     scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
                     id="photran.managedbuild.toolchain.gnu.fortran.win32.exe.release"
                     isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
                  <targetPlatform
					  id="photran.managedbuild.target.gnu.platform.fortran.win32.exe.release"
				 	  name="%PlatformName.Rel"




               osList="linux"
               name="%ToolChainName.x86"
               targetTool="photran.managedbuild.tool.intel.fortran.linker;photran.managedbuild.tool.intel.fortran.archiver"
               id="photran.managedbuild.toolchain.intel.fortran.x86.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <!-- add archList="x86,x86_64" when possible-->
		       <targetPlatform
		          id="photran.managedbuild.target.intel.platform.x86.base"

               osList="linux"
               name="%ToolChainName.x86_64"
               targetTool="photran.managedbuild.tool.intel.fortran.linker;photran.managedbuild.tool.intel.fortran.archiver"
               id="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
		       <targetPlatform
		          id="photran.managedbuild.target.intel.platform.x86_64.base"
		          name="%PlatformName.x86_64"

               osList="linux"
               name="%ToolChainName.ipf"
               targetTool="photran.managedbuild.tool.intel.fortran.linker;photran.managedbuild.tool.intel.fortran.archiver"
               id="photran.managedbuild.toolchain.intel.fortran.ipf.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.ipf.base"
                  name="%PlatformName.ipf"

	        buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.exe.x86.debug"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
		       <targetPlatform
		          id="photran.managedbuild.target.intel.platform.exe.x86.debug"
		          superClass="photran.managedbuild.target.intel.platform.x86.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.exe.x86.release"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.fortran.exe.x86.release"
                  superClass="photran.managedbuild.target.intel.platform.x86.base">

	        buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.exe.x86_64.debug"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
		       <targetPlatform
		          id="photran.managedbuild.target.intel.platform.exe.x86_64.debug"
		          superClass="photran.managedbuild.target.intel.platform.x86_64.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.exe.x86_64.release"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.fortran.exe.x86_64.release"
                  superClass="photran.managedbuild.target.intel.platform.x86_64.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.exe.ipf.debug"
               superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.exe.ipf.debug"
                  superClass="photran.managedbuild.target.intel.platform.ipf.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.exe.ipf.release"
               superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.fortran.exe.ipf.release"
                  superClass="photran.managedbuild.target.intel.platform.ipf.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.ar.x86.debug"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.ar.x86.debug"
                  superClass="photran.managedbuild.target.intel.platform.x86.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.ar.x86.release"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.fortran.ar.x86.release"
                  superClass="photran.managedbuild.target.intel.platform.x86.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.ar.x86_64.debug"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.ar.x86_64.debug"
                  superClass="photran.managedbuild.target.intel.platform.x86_64.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.ar.x86_64.release"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.fortran.ar.x86_64.release"
                  superClass="photran.managedbuild.target.intel.platform.x86_64.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.ar.ipf.debug"
               superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.ar.ipf.debug"
                  superClass="photran.managedbuild.target.intel.platform.ipf.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.ar.ipf.release"
               superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.fortran.ar.ipf.release"
                  superClass="photran.managedbuild.target.intel.platform.ipf.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.so.x86.debug"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.so.x86.debug"
                  superClass="photran.managedbuild.target.intel.platform.x86.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.so.x86.release"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.fortran.so.x86.release"
                  superClass="photran.managedbuild.target.intel.platform.x86.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.so.x86_64.debug"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.so.x86_64.debug"
                  superClass="photran.managedbuild.target.intel.platform.x86_64.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.so.x86_64.release"
               superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.fortran.so.x86_64.release"
                  superClass="photran.managedbuild.target.intel.platform.x86_64.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.so.ipf.debug"
               superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.so.ipf.debug"
                  superClass="photran.managedbuild.target.intel.platform.ipf.base">

            buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
            <toolChain
               id="photran.managedbuild.toolchain.intel.fortran.so.ipf.release"
               superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
               isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
               <targetPlatform
                  id="photran.managedbuild.target.intel.platform.fortran.so.ipf.release"
                  superClass="photran.managedbuild.target.intel.platform.ipf.base">




                     name="%XLFToolChainName.Dbg"
                     targetTool="photran.managedbuild.tool.macosx.fortran.xlf.linker.macosx.exe.debug"
                     scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
                     id="photran.managedbuild.toolchain.xlf.fortran.macosx.exe.debug"
                     isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.xlf.IsXlfToolChainSupported">
                  <!--targetPlatform
					  id="photran.managedbuild.target.xlf.platform.macosx.exe.debug"
				 	  name="%PlatformName.Dbg"

                     name="%XLFToolChainName.Rel"
                     targetTool="photran.managedbuild.tool.macosx.fortran.xlf.linker.macosx.exe.release"
                     scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
                     id="photran.managedbuild.toolchain.xlf.fortran.macosx.exe.release"
                     isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.xlf.IsXlfToolChainSupported">
                  <!--targetPlatform
					  id="photran.managedbuild.target.xlf.platform.fortran.macosx.exe.release"
				 	  name="%PlatformName.Rel"

Return to bug 397116

Lines 594-600 Link Here

(-)a/org.eclipse.photran.managedbuilder.gnu.ui/plugin.xml (-6 / +12 lines)
594	name="%ToolChainName.Dbg"	594	name="%ToolChainName.Dbg"
595	targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.debug"	595	targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.debug"
596	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"	596	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
597	id="photran.managedbuild.toolchain.gnu.fortran.exe.debug">	597	id="photran.managedbuild.toolchain.gnu.fortran.exe.debug"
		598	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
598	<targetPlatform	599	<targetPlatform
599	id="photran.managedbuild.target.gnu.platform.exe.debug"	600	id="photran.managedbuild.target.gnu.platform.exe.debug"
600	name="%PlatformName.Dbg"	601	name="%PlatformName.Dbg"
Lines 655-661 Link Here
655	name="%ToolChainName.Rel"	656	name="%ToolChainName.Rel"
656	targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.release"	657	targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.release"
657	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"	658	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
658	id="photran.managedbuild.toolchain.gnu.fortran.exe.release">	659	id="photran.managedbuild.toolchain.gnu.fortran.exe.release"
		660	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
659	<targetPlatform	661	<targetPlatform
660	id="photran.managedbuild.target.gnu.platform.fortran.exe.release"	662	id="photran.managedbuild.target.gnu.platform.fortran.exe.release"
661	name="%PlatformName.Rel"	663	name="%PlatformName.Rel"
Lines 728-734 Link Here
728	name="%ToolChainName.Dbg"	730	name="%ToolChainName.Dbg"
729	targetTool="photran.managedbuild.tool.macosx.fortran.linker.macosx.exe.debug"	731	targetTool="photran.managedbuild.tool.macosx.fortran.linker.macosx.exe.debug"
730	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"	732	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
731	id="photran.managedbuild.toolchain.gnu.fortran.macosx.exe.debug">	733	id="photran.managedbuild.toolchain.gnu.fortran.macosx.exe.debug"
		734	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
732	<targetPlatform	735	<targetPlatform
733	id="photran.managedbuild.target.gnu.platform.macosx.exe.debug"	736	id="photran.managedbuild.target.gnu.platform.macosx.exe.debug"
734	name="%PlatformName.Dbg"	737	name="%PlatformName.Dbg"
Lines 789-795 Link Here
789	name="%ToolChainName.Rel"	792	name="%ToolChainName.Rel"
790	targetTool="photran.managedbuild.tool.macosx.fortran.linker.macosx.exe.release"	793	targetTool="photran.managedbuild.tool.macosx.fortran.linker.macosx.exe.release"
791	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"	794	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
792	id="photran.managedbuild.toolchain.gnu.fortran.macosx.exe.release">	795	id="photran.managedbuild.toolchain.gnu.fortran.macosx.exe.release"
		796	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
793	<targetPlatform	797	<targetPlatform
794	id="photran.managedbuild.target.gnu.platform.fortran.macosx.exe.release"	798	id="photran.managedbuild.target.gnu.platform.fortran.macosx.exe.release"
795	name="%PlatformName.Rel"	799	name="%PlatformName.Rel"
Lines 862-868 Link Here
862	name="%ToolChainName.Dbg"	866	name="%ToolChainName.Dbg"
863	targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.debug"	867	targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.debug"
864	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"	868	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
865	id="photran.managedbuild.toolchain.gnu.fortran.win32.exe.debug">	869	id="photran.managedbuild.toolchain.gnu.fortran.win32.exe.debug"
		870	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
866	<targetPlatform	871	<targetPlatform
867	id="photran.managedbuild.target.gnu.platform.win32.exe.debug"	872	id="photran.managedbuild.target.gnu.platform.win32.exe.debug"
868	name="%PlatformName.Dbg"	873	name="%PlatformName.Dbg"
Lines 923-929 Link Here
923	name="%ToolChainName.Rel"	928	name="%ToolChainName.Rel"
924	targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.release"	929	targetTool="photran.managedbuild.tool.gnu.fortran.linker.exe.release"
925	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"	930	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
926	id="photran.managedbuild.toolchain.gnu.fortran.win32.exe.release">	931	id="photran.managedbuild.toolchain.gnu.fortran.win32.exe.release"
		932	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.gnu.IsGnuToolChainSupported">
927	<targetPlatform	933	<targetPlatform
928	id="photran.managedbuild.target.gnu.platform.fortran.win32.exe.release"	934	id="photran.managedbuild.target.gnu.platform.fortran.win32.exe.release"
929	name="%PlatformName.Rel"	935	name="%PlatformName.Rel"

Lines 1918-1924 Link Here

(-)a/org.eclipse.photran.managedbuilder.intel.ui/plugin.xml (-21 / +42 lines)
1918	osList="linux"	1918	osList="linux"
1919	name="%ToolChainName.x86"	1919	name="%ToolChainName.x86"
1920	targetTool="photran.managedbuild.tool.intel.fortran.linker;photran.managedbuild.tool.intel.fortran.archiver"	1920	targetTool="photran.managedbuild.tool.intel.fortran.linker;photran.managedbuild.tool.intel.fortran.archiver"
1921	id="photran.managedbuild.toolchain.intel.fortran.x86.base">	1921	id="photran.managedbuild.toolchain.intel.fortran.x86.base"
		1922	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
1922	<!-- add archList="x86,x86_64" when possible-->	1923	<!-- add archList="x86,x86_64" when possible-->
1923	<targetPlatform	1924	<targetPlatform
1924	id="photran.managedbuild.target.intel.platform.x86.base"	1925	id="photran.managedbuild.target.intel.platform.x86.base"
Lines 1976-1982 Link Here
1976	osList="linux"	1977	osList="linux"
1977	name="%ToolChainName.x86_64"	1978	name="%ToolChainName.x86_64"
1978	targetTool="photran.managedbuild.tool.intel.fortran.linker;photran.managedbuild.tool.intel.fortran.archiver"	1979	targetTool="photran.managedbuild.tool.intel.fortran.linker;photran.managedbuild.tool.intel.fortran.archiver"
1979	id="photran.managedbuild.toolchain.intel.fortran.x86_64.base">	1980	id="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
		1981	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
1980	<targetPlatform	1982	<targetPlatform
1981	id="photran.managedbuild.target.intel.platform.x86_64.base"	1983	id="photran.managedbuild.target.intel.platform.x86_64.base"
1982	name="%PlatformName.x86_64"	1984	name="%PlatformName.x86_64"
Lines 2032-2038 Link Here
2032	osList="linux"	2034	osList="linux"
2033	name="%ToolChainName.ipf"	2035	name="%ToolChainName.ipf"
2034	targetTool="photran.managedbuild.tool.intel.fortran.linker;photran.managedbuild.tool.intel.fortran.archiver"	2036	targetTool="photran.managedbuild.tool.intel.fortran.linker;photran.managedbuild.tool.intel.fortran.archiver"
2035	id="photran.managedbuild.toolchain.intel.fortran.ipf.base">	2037	id="photran.managedbuild.toolchain.intel.fortran.ipf.base"
		2038	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2036	<targetPlatform	2039	<targetPlatform
2037	id="photran.managedbuild.target.intel.platform.ipf.base"	2040	id="photran.managedbuild.target.intel.platform.ipf.base"
2038	name="%PlatformName.ipf"	2041	name="%PlatformName.ipf"
Lines 2117-2123 Link Here
2117	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">	2120	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
2118	<toolChain	2121	<toolChain
2119	id="photran.managedbuild.toolchain.intel.fortran.exe.x86.debug"	2122	id="photran.managedbuild.toolchain.intel.fortran.exe.x86.debug"
2120	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base">	2123	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
		2124	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2121	<targetPlatform	2125	<targetPlatform
2122	id="photran.managedbuild.target.intel.platform.exe.x86.debug"	2126	id="photran.managedbuild.target.intel.platform.exe.x86.debug"
2123	superClass="photran.managedbuild.target.intel.platform.x86.base">	2127	superClass="photran.managedbuild.target.intel.platform.x86.base">
Lines 2171-2177 Link Here
2171	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">	2175	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
2172	<toolChain	2176	<toolChain
2173	id="photran.managedbuild.toolchain.intel.fortran.exe.x86.release"	2177	id="photran.managedbuild.toolchain.intel.fortran.exe.x86.release"
2174	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base">	2178	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
		2179	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2175	<targetPlatform	2180	<targetPlatform
2176	id="photran.managedbuild.target.intel.platform.fortran.exe.x86.release"	2181	id="photran.managedbuild.target.intel.platform.fortran.exe.x86.release"
2177	superClass="photran.managedbuild.target.intel.platform.x86.base">	2182	superClass="photran.managedbuild.target.intel.platform.x86.base">
Lines 2215-2221 Link Here
2215	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">	2220	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
2216	<toolChain	2221	<toolChain
2217	id="photran.managedbuild.toolchain.intel.fortran.exe.x86_64.debug"	2222	id="photran.managedbuild.toolchain.intel.fortran.exe.x86_64.debug"
2218	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base">	2223	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
		2224	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2219	<targetPlatform	2225	<targetPlatform
2220	id="photran.managedbuild.target.intel.platform.exe.x86_64.debug"	2226	id="photran.managedbuild.target.intel.platform.exe.x86_64.debug"
2221	superClass="photran.managedbuild.target.intel.platform.x86_64.base">	2227	superClass="photran.managedbuild.target.intel.platform.x86_64.base">
Lines 2269-2275 Link Here
2269	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">	2275	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
2270	<toolChain	2276	<toolChain
2271	id="photran.managedbuild.toolchain.intel.fortran.exe.x86_64.release"	2277	id="photran.managedbuild.toolchain.intel.fortran.exe.x86_64.release"
2272	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base">	2278	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
		2279	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2273	<targetPlatform	2280	<targetPlatform
2274	id="photran.managedbuild.target.intel.platform.fortran.exe.x86_64.release"	2281	id="photran.managedbuild.target.intel.platform.fortran.exe.x86_64.release"
2275	superClass="photran.managedbuild.target.intel.platform.x86_64.base">	2282	superClass="photran.managedbuild.target.intel.platform.x86_64.base">
Lines 2314-2320 Link Here
2314	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">	2321	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
2315	<toolChain	2322	<toolChain
2316	id="photran.managedbuild.toolchain.intel.fortran.exe.ipf.debug"	2323	id="photran.managedbuild.toolchain.intel.fortran.exe.ipf.debug"
2317	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base">	2324	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
		2325	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2318	<targetPlatform	2326	<targetPlatform
2319	id="photran.managedbuild.target.intel.platform.exe.ipf.debug"	2327	id="photran.managedbuild.target.intel.platform.exe.ipf.debug"
2320	superClass="photran.managedbuild.target.intel.platform.ipf.base">	2328	superClass="photran.managedbuild.target.intel.platform.ipf.base">
Lines 2368-2374 Link Here
2368	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">	2376	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
2369	<toolChain	2377	<toolChain
2370	id="photran.managedbuild.toolchain.intel.fortran.exe.ipf.release"	2378	id="photran.managedbuild.toolchain.intel.fortran.exe.ipf.release"
2371	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base">	2379	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
		2380	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2372	<targetPlatform	2381	<targetPlatform
2373	id="photran.managedbuild.target.intel.platform.fortran.exe.ipf.release"	2382	id="photran.managedbuild.target.intel.platform.fortran.exe.ipf.release"
2374	superClass="photran.managedbuild.target.intel.platform.ipf.base">	2383	superClass="photran.managedbuild.target.intel.platform.ipf.base">
Lines 2423-2429 Link Here
2423	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">	2432	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
2424	<toolChain	2433	<toolChain
2425	id="photran.managedbuild.toolchain.intel.fortran.ar.x86.debug"	2434	id="photran.managedbuild.toolchain.intel.fortran.ar.x86.debug"
2426	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base">	2435	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
		2436	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2427	<targetPlatform	2437	<targetPlatform
2428	id="photran.managedbuild.target.intel.platform.ar.x86.debug"	2438	id="photran.managedbuild.target.intel.platform.ar.x86.debug"
2429	superClass="photran.managedbuild.target.intel.platform.x86.base">	2439	superClass="photran.managedbuild.target.intel.platform.x86.base">
Lines 2477-2483 Link Here
2477	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">	2487	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
2478	<toolChain	2488	<toolChain
2479	id="photran.managedbuild.toolchain.intel.fortran.ar.x86.release"	2489	id="photran.managedbuild.toolchain.intel.fortran.ar.x86.release"
2480	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base">	2490	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
		2491	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2481	<targetPlatform	2492	<targetPlatform
2482	id="photran.managedbuild.target.intel.platform.fortran.ar.x86.release"	2493	id="photran.managedbuild.target.intel.platform.fortran.ar.x86.release"
2483	superClass="photran.managedbuild.target.intel.platform.x86.base">	2494	superClass="photran.managedbuild.target.intel.platform.x86.base">
Lines 2521-2527 Link Here
2521	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">	2532	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
2522	<toolChain	2533	<toolChain
2523	id="photran.managedbuild.toolchain.intel.fortran.ar.x86_64.debug"	2534	id="photran.managedbuild.toolchain.intel.fortran.ar.x86_64.debug"
2524	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base">	2535	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
		2536	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2525	<targetPlatform	2537	<targetPlatform
2526	id="photran.managedbuild.target.intel.platform.ar.x86_64.debug"	2538	id="photran.managedbuild.target.intel.platform.ar.x86_64.debug"
2527	superClass="photran.managedbuild.target.intel.platform.x86_64.base">	2539	superClass="photran.managedbuild.target.intel.platform.x86_64.base">
Lines 2575-2581 Link Here
2575	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">	2587	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
2576	<toolChain	2588	<toolChain
2577	id="photran.managedbuild.toolchain.intel.fortran.ar.x86_64.release"	2589	id="photran.managedbuild.toolchain.intel.fortran.ar.x86_64.release"
2578	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base">	2590	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
		2591	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2579	<targetPlatform	2592	<targetPlatform
2580	id="photran.managedbuild.target.intel.platform.fortran.ar.x86_64.release"	2593	id="photran.managedbuild.target.intel.platform.fortran.ar.x86_64.release"
2581	superClass="photran.managedbuild.target.intel.platform.x86_64.base">	2594	superClass="photran.managedbuild.target.intel.platform.x86_64.base">
Lines 2619-2625 Link Here
2619	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">	2632	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
2620	<toolChain	2633	<toolChain
2621	id="photran.managedbuild.toolchain.intel.fortran.ar.ipf.debug"	2634	id="photran.managedbuild.toolchain.intel.fortran.ar.ipf.debug"
2622	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base">	2635	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
		2636	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2623	<targetPlatform	2637	<targetPlatform
2624	id="photran.managedbuild.target.intel.platform.ar.ipf.debug"	2638	id="photran.managedbuild.target.intel.platform.ar.ipf.debug"
2625	superClass="photran.managedbuild.target.intel.platform.ipf.base">	2639	superClass="photran.managedbuild.target.intel.platform.ipf.base">
Lines 2673-2679 Link Here
2673	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">	2687	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
2674	<toolChain	2688	<toolChain
2675	id="photran.managedbuild.toolchain.intel.fortran.ar.ipf.release"	2689	id="photran.managedbuild.toolchain.intel.fortran.ar.ipf.release"
2676	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base">	2690	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
		2691	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2677	<targetPlatform	2692	<targetPlatform
2678	id="photran.managedbuild.target.intel.platform.fortran.ar.ipf.release"	2693	id="photran.managedbuild.target.intel.platform.fortran.ar.ipf.release"
2679	superClass="photran.managedbuild.target.intel.platform.ipf.base">	2694	superClass="photran.managedbuild.target.intel.platform.ipf.base">
Lines 2727-2733 Link Here
2727	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">	2742	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
2728	<toolChain	2743	<toolChain
2729	id="photran.managedbuild.toolchain.intel.fortran.so.x86.debug"	2744	id="photran.managedbuild.toolchain.intel.fortran.so.x86.debug"
2730	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base">	2745	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
		2746	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2731	<targetPlatform	2747	<targetPlatform
2732	id="photran.managedbuild.target.intel.platform.so.x86.debug"	2748	id="photran.managedbuild.target.intel.platform.so.x86.debug"
2733	superClass="photran.managedbuild.target.intel.platform.x86.base">	2749	superClass="photran.managedbuild.target.intel.platform.x86.base">
Lines 2785-2791 Link Here
2785	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">	2801	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
2786	<toolChain	2802	<toolChain
2787	id="photran.managedbuild.toolchain.intel.fortran.so.x86.release"	2803	id="photran.managedbuild.toolchain.intel.fortran.so.x86.release"
2788	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base">	2804	superClass="photran.managedbuild.toolchain.intel.fortran.x86.base"
		2805	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2789	<targetPlatform	2806	<targetPlatform
2790	id="photran.managedbuild.target.intel.platform.fortran.so.x86.release"	2807	id="photran.managedbuild.target.intel.platform.fortran.so.x86.release"
2791	superClass="photran.managedbuild.target.intel.platform.x86.base">	2808	superClass="photran.managedbuild.target.intel.platform.x86.base">
Lines 2832-2838 Link Here
2832	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">	2849	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
2833	<toolChain	2850	<toolChain
2834	id="photran.managedbuild.toolchain.intel.fortran.so.x86_64.debug"	2851	id="photran.managedbuild.toolchain.intel.fortran.so.x86_64.debug"
2835	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base">	2852	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
		2853	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2836	<targetPlatform	2854	<targetPlatform
2837	id="photran.managedbuild.target.intel.platform.so.x86_64.debug"	2855	id="photran.managedbuild.target.intel.platform.so.x86_64.debug"
2838	superClass="photran.managedbuild.target.intel.platform.x86_64.base">	2856	superClass="photran.managedbuild.target.intel.platform.x86_64.base">
Lines 2890-2896 Link Here
2890	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">	2908	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
2891	<toolChain	2909	<toolChain
2892	id="photran.managedbuild.toolchain.intel.fortran.so.x86_64.release"	2910	id="photran.managedbuild.toolchain.intel.fortran.so.x86_64.release"
2893	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base">	2911	superClass="photran.managedbuild.toolchain.intel.fortran.x86_64.base"
		2912	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2894	<targetPlatform	2913	<targetPlatform
2895	id="photran.managedbuild.target.intel.platform.fortran.so.x86_64.release"	2914	id="photran.managedbuild.target.intel.platform.fortran.so.x86_64.release"
2896	superClass="photran.managedbuild.target.intel.platform.x86_64.base">	2915	superClass="photran.managedbuild.target.intel.platform.x86_64.base">
Lines 2937-2943 Link Here
2937	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">	2956	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug">
2938	<toolChain	2957	<toolChain
2939	id="photran.managedbuild.toolchain.intel.fortran.so.ipf.debug"	2958	id="photran.managedbuild.toolchain.intel.fortran.so.ipf.debug"
2940	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base">	2959	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
		2960	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2941	<targetPlatform	2961	<targetPlatform
2942	id="photran.managedbuild.target.intel.platform.so.ipf.debug"	2962	id="photran.managedbuild.target.intel.platform.so.ipf.debug"
2943	superClass="photran.managedbuild.target.intel.platform.ipf.base">	2963	superClass="photran.managedbuild.target.intel.platform.ipf.base">
Lines 2995-3001 Link Here
2995	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">	3015	buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release">
2996	<toolChain	3016	<toolChain
2997	id="photran.managedbuild.toolchain.intel.fortran.so.ipf.release"	3017	id="photran.managedbuild.toolchain.intel.fortran.so.ipf.release"
2998	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base">	3018	superClass="photran.managedbuild.toolchain.intel.fortran.ipf.base"
		3019	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.intel.IsIntelToolChainSupported">
2999	<targetPlatform	3020	<targetPlatform
3000	id="photran.managedbuild.target.intel.platform.fortran.so.ipf.release"	3021	id="photran.managedbuild.target.intel.platform.fortran.so.ipf.release"
3001	superClass="photran.managedbuild.target.intel.platform.ipf.base">	3022	superClass="photran.managedbuild.target.intel.platform.ipf.base">

Added Link Here

(-)a/org.eclipse.photran.cdtinterface/src/org/eclipse/photran/cdtinterface/managebuilder/BaseManageBuilderToolChainSupported.java (+85 lines)
1	/*******************************************************************************
2	* Copyright (c) 2012 Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
3	* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan and others.
4	* All rights reserved. This program and the accompanying materials
5	* are made available under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution, and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
11	* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan
12	* - Initial API and implementation
13	*******************************************************************************/
14	package org.eclipse.photran.cdtinterface.managebuilder;
15
16	import java.util.Arrays;
17
18	import org.eclipse.cdt.managedbuilder.core.IManagedIsToolChainSupported;
19	import org.eclipse.cdt.managedbuilder.core.IToolChain;
20	import org.osgi.framework.Version;
21
22	/**
23	* This class implements managed tool chain supported and outputs
24	* whether Os, Compiler and tool chain are supported
25	* @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
26	* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan
27	* - Managed Build project, Fall CS 427
28	*/
29
30	public abstract class BaseManageBuilderToolChainSupported implements IManagedIsToolChainSupported
31	{
32	private IPlatformOS platformOs = new PlatformOS();
33	private ISupportedCompiler supportedCompiler = new CompilerSupported();
34
35	/**
36	* Sets mocked OS for unit testing
37	*
38	* @param platformOs - Mock up OS to support testing.
39	*/
40	public void setPlatformOs(IPlatformOS platformOs)
41	{
42	this.platformOs = platformOs;
43	}
44
45	/**
46	* Sets mocked compiler for unit testing
47	*
48	* @param supportedCompiler - Mock up compiler to support testing.
49	*/
50	public void setCompilerSupported(ISupportedCompiler supportedCompiler)
51	{
52	this.supportedCompiler = supportedCompiler;
53	}
54
55	/**
56	* @return <code>true</code> if the given tool-chain is supported on the system
57	* otherwise returns <code>false</code>
58	*
59	*/
60	public boolean isSupported(IToolChain toolChain, Version version, String instance)
61	{
62	return isOsSupported(toolChain) && isCompilerSupported();
63	}
64
65	protected abstract boolean isCompilerSupported();
66
67	/**
68	* @return <code>true</code> if the given OS in the tool-chain is supported on
69	* the system otherwise returns <code>false</code>
70	*
71	*/
72	private boolean isOsSupported(IToolChain toolChain)
73	{
74	return Arrays.asList(toolChain.getOSList()).contains(platformOs.getOS());
75	}
76
77	/**
78	* @return <code>true</code> if the given compiler executable and version is
79	* supported on the system otherwise returns <code>false</code>
80	*
81	*/
82	protected boolean isCompilerSupported(String compilerExecutable, String versionFlag){
83	return this.supportedCompiler.isSupported(compilerExecutable, versionFlag);
84	}
85	}

Lines 25-36 Link Here

(-)a/org.eclipse.photran.core.vpg.tests/src/org/eclipse/photran/internal/tests/PhotranWorkspaceTestCase.java (-1 / +37 lines)
25	import java.net.URISyntaxException;	25	import java.net.URISyntaxException;
26	import java.net.URL;	26	import java.net.URL;
27	import java.util.ArrayList;	27	import java.util.ArrayList;
		28	import java.util.Arrays;
28	import java.util.HashMap;	29	import java.util.HashMap;
		30	import java.util.List;
29		31
30	import org.eclipse.cdt.core.CCorePlugin;	32	import org.eclipse.cdt.core.CCorePlugin;
31	import org.eclipse.cdt.core.dom.IPDOMManager;	33	import org.eclipse.cdt.core.dom.IPDOMManager;
		34	import org.eclipse.cdt.core.model.CoreModel;
32	import org.eclipse.cdt.core.model.ICProject;	35	import org.eclipse.cdt.core.model.ICProject;
		36	import org.eclipse.cdt.core.settings.model.CIncludePathEntry;
		37	import org.eclipse.cdt.core.settings.model.ICConfigurationDescription;
		38	import org.eclipse.cdt.core.settings.model.ICFolderDescription;
		39	import org.eclipse.cdt.core.settings.model.ICLanguageSetting;
		40	import org.eclipse.cdt.core.settings.model.ICLanguageSettingEntry;
		41	import org.eclipse.cdt.core.settings.model.ICProjectDescription;
		42	import org.eclipse.cdt.core.settings.model.ICSettingEntry;
33	import org.eclipse.core.resources.IFile;	43	import org.eclipse.core.resources.IFile;
		44	import org.eclipse.core.resources.IFolder;
34	import org.eclipse.core.resources.IProject;	45	import org.eclipse.core.resources.IProject;
35	import org.eclipse.core.resources.IResource;	46	import org.eclipse.core.resources.IResource;
36	import org.eclipse.core.resources.IWorkspace;	47	import org.eclipse.core.resources.IWorkspace;
Lines 60-65 Link Here
60	* @author Jeff Overbey - Modified so that every test case creates a new project - Added line/column	71	* @author Jeff Overbey - Modified so that every test case creates a new project - Added line/column
61	* computation when importing files - Added {@link #compileAndRunFortranProgram(String...)}	72	* computation when importing files - Added {@link #compileAndRunFortranProgram(String...)}
62	* Also added marker infrastructure.	73	* Also added marker infrastructure.
		74	* @author Mehrdad Biglari, Ramesh Kolavenu, Lorentz Arthur Morrow,
		75	* Jose Alberto Lozano Hinojosa, Michael T O'Sullivan - Modified to
		76	* create test sub directories to avoid overwriting test file contents
		77	* when file names are identical in sub directories.
63	*/	78	*/
64	public abstract class PhotranWorkspaceTestCase extends PhotranTestCase {	79	public abstract class PhotranWorkspaceTestCase extends PhotranTestCase {
65		80
Lines 169-176 Link Here
169	PhotranVPG.getInstance().clearDatabase();	184	PhotranVPG.getInstance().clearDatabase();
170	}	185	}
171	project = null;	186	project = null;
172	}	187	}
173		188
		189	// import file with test directory
		190	protected IFile importFile(String testSrcDir, String fileName, String contents) throws Exception
		191	{
		192	if(testSrcDir != null && testSrcDir != "")
		193	{
		194	IFolder folder = project.getProject().getFolder(testSrcDir);
		195	if(!folder.exists())
		196	folder.create(true, false, monitor);
		197	fileName = "/" + testSrcDir + "/" + fileName;
		198	}
		199	return importFile(fileName, contents);
		200	}
		201
174	protected IFile importFile(String fileName, String contents) throws Exception	202	protected IFile importFile(String fileName, String contents) throws Exception
175	{	203	{
176	//Obtain file handle	204	//Obtain file handle
Lines 282-287 Link Here
282	return result;	310	return result;
283	}	311	}
284		312
		313	protected IFile importFile(Plugin activator, String srcDir, String filename, String testSrcDir) throws Exception
		314	{
		315	//project.getProject().getFile(filename).delete(true, new NullProgressMonitor());
		316	IFile result = importFile(testSrcDir, filename, readTestFile(activator, srcDir, filename));
		317	//project.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
		318	return result;
		319	}
		320
285	protected String readTestFile(Plugin activator, String srcDir, String filename) throws IOException, URISyntaxException	321	protected String readTestFile(Plugin activator, String srcDir, String filename) throws IOException, URISyntaxException
286	{	322	{
287	ArrayList<Integer> lineMap = new ArrayList<Integer>(50);	323	ArrayList<Integer> lineMap = new ArrayList<Integer>(50);

Lines 418-424 Link Here

(-)a/org.eclipse.photran.managedbuilder.xlf.ui/plugin.xml (-2 / +4 lines)
418	name="%XLFToolChainName.Dbg"	418	name="%XLFToolChainName.Dbg"
419	targetTool="photran.managedbuild.tool.macosx.fortran.xlf.linker.macosx.exe.debug"	419	targetTool="photran.managedbuild.tool.macosx.fortran.xlf.linker.macosx.exe.debug"
420	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"	420	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
421	id="photran.managedbuild.toolchain.xlf.fortran.macosx.exe.debug">	421	id="photran.managedbuild.toolchain.xlf.fortran.macosx.exe.debug"
		422	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.xlf.IsXlfToolChainSupported">
422	<!--targetPlatform	423	<!--targetPlatform
423	id="photran.managedbuild.target.xlf.platform.macosx.exe.debug"	424	id="photran.managedbuild.target.xlf.platform.macosx.exe.debug"
424	name="%PlatformName.Dbg"	425	name="%PlatformName.Dbg"
Lines 479-485 Link Here
479	name="%XLFToolChainName.Rel"	480	name="%XLFToolChainName.Rel"
480	targetTool="photran.managedbuild.tool.macosx.fortran.xlf.linker.macosx.exe.release"	481	targetTool="photran.managedbuild.tool.macosx.fortran.xlf.linker.macosx.exe.release"
481	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"	482	scannerConfigDiscoveryProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfile"
482	id="photran.managedbuild.toolchain.xlf.fortran.macosx.exe.release">	483	id="photran.managedbuild.toolchain.xlf.fortran.macosx.exe.release"
		484	isToolChainSupported="org.eclipse.photran.cdtinterface.managebuilder.xlf.IsXlfToolChainSupported">
483	<!--targetPlatform	485	<!--targetPlatform
484	id="photran.managedbuild.target.xlf.platform.fortran.macosx.exe.release"	486	id="photran.managedbuild.target.xlf.platform.fortran.macosx.exe.release"
485	name="%PlatformName.Rel"	487	name="%PlatformName.Rel"