mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-04-29 19:45:01 +02:00
Code Issues Wiki Activity

Patch for Sean Evoy.

Browse source 
The change logs contain an overview of what has been done to implement a new interface between a build model (any build model) 
and clients of the model that need to extract include search paths and defined symbols. For the most part, I have tried to leave the 
old build system as unchanged as possible. For example, project properties like the make search path, and whether or not to continue 
on build failures are still stored as persistent properties on the project through the CNature (ugh). The new information I have added 
is managed by a new build manager on a per-project basis and is associated with a project as a session property. The information is 
persisted in the 'cdtbuild' file introduced by the new managed build system.
This commit is contained in:
John Camelon 2003-07-04 18:36:47 +00:00
parent 2e6093590f
commit 8b844d54f1
21 changed files with 1386 additions and 233 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
core/org.eclipse.cdt.core.tests/ChangeLog
View file

@ -16,6 +16,16 @@
Added IndexManagerTest::testRemoveProjectFromIndex()
Added IndexManagerTest::testRemoveFileFromIndex()
2003-07-03 Sean Evoy
New test suite that exercises the standard make build system including the new
IScannerInfoListener and IScannerInfoProvider interfaces.
Changes to the existing managed build test suite include tests of the new
IScannerInfoxxx interface discovery, subscription, and change notification methods.
* build/org/eclipse/cdt/core/build/managed/tests/StandardBuildTests.java
* build/org/eclipse/cdt/core/build/managed/tests/AllBuildTests.java
2003-07-02 Victor Mozgin
Added DOMTests::testBug39501().
Improved filtering of expected failures/inconclusives in TortureTest.

90
core/org.eclipse.cdt.core.tests/build/org/eclipse/cdt/core/build/managed/tests/AllBuildTests.java
View file

@ -12,36 +12,40 @@ package org.eclipse.cdt.core.build.managed.tests;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.build.managed.BuildException;
import org.eclipse.cdt.core.build.managed.IConfiguration;
import org.eclipse.cdt.core.build.managed.IManagedBuildPathInfo;
import org.eclipse.cdt.core.build.managed.IOption;
import org.eclipse.cdt.core.build.managed.IOptionCategory;
import org.eclipse.cdt.core.build.managed.IResourceBuildInfo;
import org.eclipse.cdt.core.build.managed.IManagedBuildInfo;
import org.eclipse.cdt.core.build.managed.ITarget;
import org.eclipse.cdt.core.build.managed.ITool;
import org.eclipse.cdt.core.build.managed.ManagedBuildManager;
import org.eclipse.cdt.core.parser.IScannerInfo;
import org.eclipse.cdt.core.parser.IScannerInfoChangeListener;
import org.eclipse.cdt.core.parser.IScannerInfoProvider;
import org.eclipse.cdt.internal.core.build.managed.ToolReference;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
/**
*
*/
public class AllBuildTests extends TestCase {
private static final boolean boolVal = true;
private static final String testConfigName = "test.config.override";
private static final String enumVal = "Another Enum";
private static final String[] listVal = {"_DEBUG", "/usr/include", "libglade.a"};
private static final String projectName = "BuildTest";
private static final String projectName = "ManagedBuildTest";
private static final String rootExt = "toor";
private static final String stringVal = "-c -Wall";
private static final String subExt = "bus";
@ -57,7 +61,7 @@ public class AllBuildTests extends TestCase {
suite.addTest(new AllBuildTests("testProject"));
suite.addTest(new AllBuildTests("testConfigurations"));
suite.addTest(new AllBuildTests("testTargetArtifacts"));
suite.addTest(new AllBuildTests("testBuildPathInfoInterface"));
suite.addTest(new AllBuildTests("testScannerInfoInterface"));
suite.addTest(new AllBuildTests("cleanup"));
return suite;
@ -98,7 +102,7 @@ public class AllBuildTests extends TestCase {
*
* @throws CoreException
*/
public void testBuildPathInfoInterface(){
public void testScannerInfoInterface(){
// Open the test project
IProject project = null;
try {
@ -126,25 +130,55 @@ public class AllBuildTests extends TestCase {
// Change the default configuration to the sub config
IConfiguration[] configs = newTarget.getConfigurations();
assertEquals(3, configs.length);
IResourceBuildInfo buildInfo = ManagedBuildManager.getBuildInfo(project);
IManagedBuildInfo buildInfo = ManagedBuildManager.getBuildInfo(project);
buildInfo.setDefaultConfiguration(newTarget.getConfiguration("sub.config.2"));
// Get the path information for the project
IManagedBuildPathInfo info = ManagedBuildManager.getBuildPathInfo(project);
assertNotNull(info);
// Test the interface for include paths. It is important that the build model
// return the contents of all options flagged as containing include paths
String[] expectedPaths = {"/usr/include", "/opt/gnome/include", "/home/tester/include"};
String[] actualPaths = info.getIncludePaths();
assertTrue(Arrays.equals(expectedPaths, actualPaths));
// Test the interface for defined symbols (there are none but it should not return null)
String[] definedSymbols = info.getDefinedSymbols();
assertNotNull(definedSymbols);
assertEquals(0, definedSymbols.length);
// Use the plugin mechanism to discover the supplier of the path information
IExtensionPoint extensionPoint = CCorePlugin.getDefault().getDescriptor().getExtensionPoint("ScannerInfoProvider");
if (extensionPoint == null) {
fail("Failed to retrieve the extension point ScannerInfoProvider.");
}
IExtension[] extensions = extensionPoint.getExtensions();
IScannerInfoProvider provider = null;
// Find the first IScannerInfoProvider that supplies build info for the project
for (int i = 0; i < extensions.length && provider == null; i++) {
IExtension extension = extensions[i];
IConfigurationElement[] elements = extension.getConfigurationElements();
for (int j = 0; j < elements.length; ++j) {
IConfigurationElement element = elements[j];
if (element.getName().equals("provider")) {
// Check if it handles the info for the project
try {
IScannerInfoProvider temp = (IScannerInfoProvider)element.createExecutableExtension("class");
if (temp.managesResource(project)) {
provider = temp;
break;
}
} catch (CoreException e) {
fail("Failed retrieving scanner info provider from plugin: " + e.getLocalizedMessage());
}
}
}
}
assertNotNull(provider);
provider.subscribe(project, new IScannerInfoChangeListener () {
public void changeNotification(IResource project, IScannerInfo info) {
// Test the symbols
Map definedSymbols = info.getDefinedSymbols();
assertTrue(definedSymbols.containsKey("DEBUG"));
assertTrue(definedSymbols.containsKey("GNOME"));
assertTrue(definedSymbols.containsValue("ME"));
assertEquals((String)definedSymbols.get("DEBUG"), "");
assertEquals((String)definedSymbols.get("GNOME"), "ME");
// Test the includes path
String[] expectedPaths = {"/usr/include", "/opt/gnome/include", "/home/tester/include"};
String[] actualPaths = info.getIncludePaths();
assertTrue(Arrays.equals(expectedPaths, actualPaths));
}
});
// Add some defined symbols programmatically
String[] expectedSymbols = {"DEBUG", "GNOME"};
String[] expectedSymbols = {"DEBUG", "GNOME = ME "};
IConfiguration defaultConfig = buildInfo.getDefaultConfiguration(newTarget);
ITool[] tools = defaultConfig.getTools();
ITool subTool = null;
@ -167,10 +201,6 @@ public class AllBuildTests extends TestCase {
}
assertNotNull(symbolOpt);
ManagedBuildManager.setOption(defaultConfig, symbolOpt, expectedSymbols);
// Retest
definedSymbols = info.getDefinedSymbols();
assertTrue(Arrays.equals(expectedSymbols, definedSymbols));
}
/**
@ -302,7 +332,7 @@ public class AllBuildTests extends TestCase {
}
// Test that the default config was remembered
IResourceBuildInfo info = ManagedBuildManager.getBuildInfo(project);
IManagedBuildInfo info = ManagedBuildManager.getBuildInfo(project);
assertEquals(defaultConfig.getId(), info.getDefaultConfiguration(target).getId());
// Get the targets
@ -324,7 +354,7 @@ public class AllBuildTests extends TestCase {
*
* @param project
*/
private void checkBuildTestSettings(IResourceBuildInfo info) {
private void checkBuildTestSettings(IManagedBuildInfo info) {
String ext1 = "foo";
String ext2 = "bar";
String badExt = "cpp";
@ -332,7 +362,7 @@ public class AllBuildTests extends TestCase {
String expectedCmd = "doIt";
assertNotNull(info);
assertEquals(info.getBuildArtifactName(), "BuildTest.toor");
assertEquals(info.getBuildArtifactName(), projectName + "." + rootExt);
// There should be a default configuration defined for the project
ITarget buildTarget = info.getDefaultTarget();

374
core/org.eclipse.cdt.core.tests/build/org/eclipse/cdt/core/build/managed/tests/StandardBuildTests.java Normal file
View file

@ -0,0 +1,374 @@
package org.eclipse.cdt.core.build.managed.tests;
import java.util.Arrays;
import java.util.Map;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.eclipse.cdt.core.CCProjectNature;
import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.CProjectNature;
import org.eclipse.cdt.core.build.standard.StandardBuildManager;
import org.eclipse.cdt.core.parser.IScannerInfo;
import org.eclipse.cdt.core.parser.IScannerInfoChangeListener;
import org.eclipse.cdt.core.parser.IScannerInfoProvider;
import org.eclipse.cdt.core.resources.IStandardBuildInfo;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.NullProgressMonitor;
/**********************************************************************
* Copyright (c) 2002,2003 Rational Software Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v0.5
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v05.html
*
* Contributors:
* IBM Rational Software - Initial API and implementation
***********************************************************************/
public class StandardBuildTests extends TestCase {
private static final String DEFAULT_MAKE_CMD = "make";
private static final String EMPTY_STRING = "";
private static final boolean OFF = false;
private static final boolean ON = true;
private static final String OVR_BUILD_ARGS = "all";
private static final String OVR_BUILD_LOCATION = "/home/tester/bin/nmake";
private static final String[] OVR_INC_PATHS = {"/test", "C:\\windows", "//dev/home/include"};
private static final String[] OVR_PREPROC_SYMS = {"_RELEASE", "NO ", " YES=1"};
private static final String PROJECT_NAME = "StandardBuildTest";
private class ScannerListener implements IScannerInfoChangeListener {
private final String[] expectedPaths = {"/usr/include", "/home/tester/include", "/opt/gnome/include"};
private final String[] expectedSymbols = {"_DEBUG", "TRUE=1", "FALSE ", ""};
public void changeNotification(IResource project, IScannerInfo info) {
// Are there any symbols
Map definedSymbols = info.getDefinedSymbols();
if (!definedSymbols.isEmpty()) {
assertTrue(definedSymbols.containsKey(expectedSymbols[0]));
assertEquals(EMPTY_STRING, (String)definedSymbols.get(expectedSymbols[0]));
assertTrue(definedSymbols.containsKey("TRUE"));
assertEquals("1", (String)definedSymbols.get("TRUE"));
assertFalse(definedSymbols.containsKey(expectedSymbols[2]));
assertTrue(definedSymbols.containsKey(expectedSymbols[2].trim()));
assertEquals(EMPTY_STRING, (String)definedSymbols.get(expectedSymbols[2].trim()));
// We should have discarded the empty string
assertFalse(definedSymbols.containsKey(""));
}
// What paths have been set
String[] paths = info.getIncludePaths();
if (paths.length > 0) {
assertTrue(Arrays.equals(expectedPaths, paths));
}
}
/**
* @return
*/
public String[] getExpectedPaths() {
return expectedPaths;
}
/**
* @return
*/
public String[] getExpectedSymbols() {
return expectedSymbols;
}
}
/**
* @param name
*/
public StandardBuildTests(String name) {
super(name);
}
public static Test suite() {
TestSuite suite = new TestSuite(StandardBuildTests.class.getName());
// Add the relevant tests to the suite
suite.addTest(new StandardBuildTests("testProjectCreation"));
suite.addTest(new StandardBuildTests("testProjectSettings"));
suite.addTest(new StandardBuildTests("testProjectConversion"));
suite.addTest(new StandardBuildTests("testScannerListenerInterface"));
suite.addTest(new StandardBuildTests("testProjectCleanup"));
return suite;
}
private void checkDefaultProjectSettings(IProject project) {
assertNotNull(project);
// There should not be any include path or defined symbols for the project
IStandardBuildInfo info = StandardBuildManager.getBuildInfo(project);
assertNotNull(info);
String[] includePaths = info.getIncludePaths();
assertNotNull(includePaths);
assertEquals(0, includePaths.length);
String[] definedSymbols = info.getPreprocessorSymbols();
assertNotNull(definedSymbols);
assertEquals(0, definedSymbols.length);
// Check the rest of the project information
assertEquals(ON, info.isDefaultBuildCmd());
assertEquals(OFF,info.isStopOnError());
assertEquals(DEFAULT_MAKE_CMD, info.getBuildLocation());
assertEquals(EMPTY_STRING, info.getFullBuildArguments());
assertEquals(EMPTY_STRING, info.getIncrementalBuildArguments());
}
private void checkOverriddenProjectSettings(IProject project) {
assertNotNull(project);
// Check that the new stuff is there
IStandardBuildInfo info = StandardBuildManager.getBuildInfo(project);
assertNotNull(info);
String[] includePaths = info.getIncludePaths();
assertNotNull(includePaths);
assertEquals(3, includePaths.length);
assertTrue(Arrays.equals(includePaths, OVR_INC_PATHS));
String[] definedSymbols = info.getPreprocessorSymbols();
assertNotNull(definedSymbols);
assertEquals(3, definedSymbols.length);
assertTrue(Arrays.equals(definedSymbols, OVR_PREPROC_SYMS));
// Check the rest of the project information
assertEquals(OFF, info.isDefaultBuildCmd());
assertEquals(ON, info.isStopOnError());
assertEquals(OVR_BUILD_LOCATION, info.getBuildLocation());
assertEquals(OVR_BUILD_ARGS, info.getFullBuildArguments());
assertEquals(EMPTY_STRING, info.getIncrementalBuildArguments());
}
/**
* Create a new project named <code>name</code> or return the project in
* the workspace of the same name if it exists.
*
* @param name The name of the project to create or retrieve.
* @return
* @throws CoreException
*/
private IProject createProject(String name) throws CoreException {
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IProject project = root.getProject(name);
if (!project.exists()) {
project.create(null);
} else {
project.refreshLocal(IResource.DEPTH_INFINITE, null);
}
if (!project.isOpen()) {
project.open(null);
}
return project;
}
private IScannerInfoProvider findInfoProvider(IProject project) {
// Use the plugin mechanism to discover the supplier of the path information
IExtensionPoint extensionPoint = CCorePlugin.getDefault().getDescriptor().getExtensionPoint("ScannerInfoProvider");
if (extensionPoint == null) {
fail("StandardBuildTest testScannerListernerInterface failed to retrieve the extension point ScannerInfoProvider.");
}
IExtension[] extensions = extensionPoint.getExtensions();
IScannerInfoProvider provider = null;
// Find the first IScannerInfoProvider that supplies build info for the project
for (int i = 0; i < extensions.length && provider == null; i++) {
IExtension extension = extensions[i];
IConfigurationElement[] elements = extension.getConfigurationElements();
for (int j = 0; j < elements.length; ++j) {
IConfigurationElement element = elements[j];
if (element.getName().equals("provider")) {
// Check if it handles the info for the project
try {
IScannerInfoProvider temp = (IScannerInfoProvider)element.createExecutableExtension("class");
if (temp.managesResource(project)) {
provider = temp;
break;
}
} catch (CoreException e) {
fail("Failed retrieving scanner info provider from plugin: " + e.getLocalizedMessage());
}
}
}
}
return provider;
}
/**
* Remove the <code>IProject</code> with the name specified in the argument from the
* receiver's workspace.
*
* @param name
*/
private void removeProject(String name) {
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IProject project = root.getProject(name);
if (project.exists()) {
try {
project.delete(true, false, null);
} catch (CoreException e) {
assertTrue(false);
}
}
}
/**
* Remove all the project information associated with the project used during test.
*/
public void testProjectCleanup() {
removeProject(PROJECT_NAME);
}
public void testProjectConversion() {
// Open the project
IProject project = null;
try {
project = createProject(PROJECT_NAME);
} catch (CoreException e) {
fail("StandardBuildTest testProjectConversion failed opening project: " + e.getLocalizedMessage());
}
assertNotNull(project);
// Check the settings (they should be the override values)
checkOverriddenProjectSettings(project);
// Now convert the project
try {
CCorePlugin.getDefault().convertProjectFromCtoCC(project, new NullProgressMonitor());
} catch (CoreException e) {
fail("StandardBuildTest testProjectConversion failed to convert project: " + e.getLocalizedMessage());
}
// Save, Close, and Reopen the project
StandardBuildManager.saveBuildInfo(project);
try {
project.close(new NullProgressMonitor());
} catch (CoreException e) {
fail("StandardBuildTest testProjectConversion failed to close project " + e.getLocalizedMessage());
}
StandardBuildManager.removeBuildInfo(project);
try {
project.open(new NullProgressMonitor());
} catch (CoreException e) {
fail ("StandardBuildTest testProjectConversion failed to open project " + e.getLocalizedMessage());
}
// Make sure it has a CCNature
try {
project.hasNature(CCProjectNature.CC_NATURE_ID);
} catch (CoreException e) {
fail("StandardBuildTest testProjectConversion failed getting nature: " + e.getLocalizedMessage());
}
// Nothing should have changed in the settings
checkOverriddenProjectSettings(project);
}
/**
*
*/
public void testProjectCreation () {
// Create a new project
IProject project = null;
try {
project = createProject(PROJECT_NAME);
// Convert the new project to a standard make project
CCorePlugin.getDefault().convertProjectToCC(project, new NullProgressMonitor(), CCorePlugin.PLUGIN_ID + ".make");
} catch (CoreException e) {
fail("StandardBuildTest testProjectCreation failed creating project: " + e.getLocalizedMessage());
}
assertNotNull(project);
// Make sure it has a CNature
try {
project.hasNature(CProjectNature.C_NATURE_ID);
} catch (CoreException e) {
fail("StandardBuildTest testProjectCreation failed getting nature: " + e.getLocalizedMessage());
}
// Check the default settings
checkDefaultProjectSettings(project);
}
public void testProjectSettings() {
// Get the project
IProject project = null;
try {
project = createProject(PROJECT_NAME);
} catch (CoreException e) {
fail("StandardBuildTest testProjectSettings failed opening project: " + e.getLocalizedMessage());
}
assertNotNull(project);
// Change the settings
StandardBuildManager.setIncludePaths(project, OVR_INC_PATHS);
StandardBuildManager.setPreprocessorSymbols(project, OVR_PREPROC_SYMS);
// Use the build info for the rest of the settings
IStandardBuildInfo info = StandardBuildManager.getBuildInfo(project);
info.setStopOnError(ON);
info.setUseDefaultBuildCmd(OFF);
info.setBuildLocation(OVR_BUILD_LOCATION);
info.setFullBuildArguments(OVR_BUILD_ARGS);
// Save, Close, and Reopen the project
StandardBuildManager.saveBuildInfo(project);
try {
project.close(new NullProgressMonitor());
} catch (CoreException e) {
fail("StandardBuildTest testProjectSettings failed to close project " + e.getLocalizedMessage());
}
StandardBuildManager.removeBuildInfo(project);
try {
project.open(new NullProgressMonitor());
} catch (CoreException e) {
fail ("StandardBuildTest testProjectSettings failed to open project " + e.getLocalizedMessage());
}
// Retest
checkOverriddenProjectSettings(project);
}
public void testScannerListenerInterface() {
// Get the project
IProject project = null;
try {
project = createProject(PROJECT_NAME);
} catch (CoreException e) {
fail("StandardBuildTest testScannerListernerInterface failed opening project: " + e.getLocalizedMessage());
}
assertNotNull(project);
// Find the scanner info provider for this project
IScannerInfoProvider provider = findInfoProvider(project);
assertNotNull(provider);
// Remove what's there
StandardBuildManager.setIncludePaths(project, new String[0]);
StandardBuildManager.setPreprocessorSymbols(project, new String[0]);
// Subscribe
ScannerListener listener = new ScannerListener();
provider.subscribe(project, listener);
// Change the settings
StandardBuildManager.setIncludePaths(project, listener.getExpectedPaths());
StandardBuildManager.setPreprocessorSymbols(project, listener.getExpectedSymbols());
// Unsubscribe
provider.unsubscribe(project, listener);
}
}

54
core/org.eclipse.cdt.core/ChangeLog
View file

@ -19,6 +19,60 @@
* src/org/eclipse/cdt/internal/core/model/CModelManager.java
2003-07-03 Sean Evoy
New schema and extension point for registering an interface
between the build system (managed and standard) and the scanner
clients that need it (like the indexer).
* plugin.xml
* schema/ScannerInfoProvider.exsd
Added some documentation to the schema for managed build information
* schema/ManagedBuildTools.exsd
Added three new interfaces for getting build information for the scanner.
IScannerInfo contains the actual information the scanner needs and is passed
to the scanner by the build model. IScannerInfoChangeListener is the interface
that must be implemented by the scanner client that uses the IScannerInfo.
IScannerInfoProvider is the interface implemented by the build model. It is
registered through an extension point so clients can discover providers at
run time. IScannerInfoListener implementors subscribe and unsubscribe with the
provider and the provider passes them the IScannerInfo when it changes.
* parser/org/eclipse/cdt/core/parser/IScannerInfo.java
* parser/org/eclipse/cdt/core/parser/IScannerInfoChangeListener.java
* parser/org/eclipse/cdt/core/parser/IScannerInfoProvider.java
Changed the name of some of the managed build system elements.
* build/org/eclipse/cdt/core/build/managed/IManagedBuildInfo.java
This resulted in superficial changes to the Target and ManagedBuildManager
* build/org/eclipse/cdt/internal/core/build/managed/Target.java
Implemented the new scanner interfaces in the managed system
* build/org/eclipse/cdt/internal/core/build/managed/ManagedBuildInfo.java
* build/org/eclipse/cdt/core/build/managed/ManagedBuildManager.java
Added a new manager for the standard make system that implements the new
scanner interfaces. This manager uses the .cdtbuild file to persist
include path and symbol information (in otherwords, real build information).
Like the managed build manager, it also gives clients access to the build
information associated with a project. It does not effect the older preferences
which are still managed by the CNature.
* build/org/eclipse/cdt/core/build/standard/StandardBuildManager.java
Removed the responsibiolity for includes paths and symbols from CNature
added in last patch.
* src/org/eclipse/cdt/core/CProjectNature.java
Added code for persisting the standard build information for includes paths and
symbols in a file, and implemented the IScannerInfo interface in the BuildInfoFactory.
Did not rename it, although ...
* src/org/eclipse/cdt/core/BuildInfoFactory.java
I did rename the interface it implements since it was the only reference
* src/org/eclipse/cdt/core/resources/IStandardBuildInfo.java
2003-06-26 Sean Evoy
Added methods to add and extract include paths and preprocessor
symbols from standard make C and C++ projects.

2
core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IResourceBuildInfo.java → core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IManagedBuildInfo.java
View file

@ -13,7 +13,7 @@ import java.util.List;
* IBM Rational Software - Initial API and implementation
***********************************************************************/
public interface IResourceBuildInfo {
public interface IManagedBuildInfo {
/**
* Add a new target to the build information for the receiver

172
core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/ManagedBuildManager.java
View file

@ -17,6 +17,7 @@ import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
@ -28,7 +29,8 @@ import org.apache.xml.serialize.OutputFormat;
import org.apache.xml.serialize.Serializer;
import org.apache.xml.serialize.SerializerFactory;
import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.internal.core.build.managed.ResourceBuildInfo;
import org.eclipse.cdt.core.parser.*;
import org.eclipse.cdt.internal.core.build.managed.ManagedBuildInfo;
import org.eclipse.cdt.internal.core.build.managed.Target;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
@ -46,11 +48,12 @@ import org.w3c.dom.Node;
* This is the main entry point for getting at the build information
* for the managed build system.
*/
public class ManagedBuildManager {
public class ManagedBuildManager implements IScannerInfoProvider {
private static final QualifiedName buildInfoProperty
= new QualifiedName(CCorePlugin.PLUGIN_ID, "buildInfo");
= new QualifiedName(CCorePlugin.PLUGIN_ID, "managedBuildInfo");
private static final String ROOT_ELEM_NAME = "ManagedProjectBuildInfo";
private static final String FILE_NAME = ".cdtbuild";
private static final ITarget[] emptyTargets = new ITarget[0];
// Targets defined by extensions (i.e., not associated with a resource)
@ -58,6 +61,9 @@ public class ManagedBuildManager {
private static List extensionTargets;
private static Map extensionTargetMap;
// Listeners interested in build model changes
private static Map buildModelListeners;
/**
* Returns the list of targets that are defined by this project,
* projects referenced by this project, and by the extensions.
@ -108,7 +114,7 @@ public class ManagedBuildManager {
* @return
*/
public static ITarget[] getTargets(IResource resource) {
IResourceBuildInfo buildInfo = getBuildInfo(resource);
IManagedBuildInfo buildInfo = getBuildInfo(resource);
if (buildInfo != null) {
List targets = buildInfo.getTargets();
@ -131,7 +137,7 @@ public class ManagedBuildManager {
ITarget target = null;
// Check if the target is spec'd in the build info for the resource
if (resource != null) {
IResourceBuildInfo buildInfo = getBuildInfo(resource);
IManagedBuildInfo buildInfo = getBuildInfo(resource);
if (buildInfo != null)
target = buildInfo.getTarget(id);
}
@ -187,12 +193,34 @@ public class ManagedBuildManager {
return;
}
// Set the default in build information for the project
IResourceBuildInfo info = getBuildInfo(project);
IManagedBuildInfo info = getBuildInfo(project);
if (info != null) {
info.setDefaultConfiguration(newDefault);
}
}
/**
* @param config
* @param option
*/
private static void setDirty(IConfiguration config, IOption option) {
// Don't bother unless this is something that effect the
if (!(option.getValueType() == IOption.INCLUDE_PATH
|| option.getValueType() == IOption.PREPROCESSOR_SYMBOLS)) {
return;
}
// Figure out if there is a listener for this change
IResource resource = config.getOwner();
List listeners = (List) getBuildModelListeners().get(resource);
if (listeners == null) {
return;
}
ListIterator iter = listeners.listIterator();
while (iter.hasNext()) {
((IScannerInfoChangeListener)iter.next()).changeNotification(resource, getScannerInfo(resource));
}
}
/**
* Set the string value for an option for a given config.
*
@ -203,6 +231,7 @@ public class ManagedBuildManager {
public static void setOption(IConfiguration config, IOption option, boolean value) {
try {
config.setOption(option, value);
setDirty(config, option);
} catch (BuildException e) {
return;
}
@ -218,6 +247,7 @@ public class ManagedBuildManager {
public static void setOption(IConfiguration config, IOption option, String value) {
try {
config.setOption(option, value);
setDirty(config, option);
} catch (BuildException e) {
return;
}
@ -233,6 +263,7 @@ public class ManagedBuildManager {
public static void setOption(IConfiguration config, IOption option, String[] value) {
try {
config.setOption(option, value);
setDirty(config, option);
} catch (BuildException e) {
return;
}
@ -247,11 +278,11 @@ public class ManagedBuildManager {
public static void saveBuildInfo(IProject project) {
// Create document
Document doc = new DocumentImpl();
Element rootElement = doc.createElement("buildInfo");
Element rootElement = doc.createElement(ROOT_ELEM_NAME);
doc.appendChild(rootElement);
// Save the build info
ResourceBuildInfo buildInfo = (ResourceBuildInfo) getBuildInfo(project);
ManagedBuildInfo buildInfo = (ManagedBuildInfo) getBuildInfo(project);
if (buildInfo != null)
buildInfo.serialize(doc, rootElement);
@ -266,7 +297,7 @@ public class ManagedBuildManager {
= SerializerFactory.getSerializerFactory(Method.XML).makeSerializer(new OutputStreamWriter(s, "UTF8"), format);
serializer.asDOMSerializer().serialize(doc);
xml = s.toString("UTF8"); //$NON-NLS-1$
IFile rscFile = project.getFile(".cdtbuild");
IFile rscFile = project.getFile(FILE_NAME);
InputStream inputStream = new ByteArrayInputStream(xml.getBytes());
// update the resource content
if (rscFile.exists()) {
@ -316,9 +347,9 @@ public class ManagedBuildManager {
}
}
private static ResourceBuildInfo loadBuildInfo(IProject project) {
ResourceBuildInfo buildInfo = null;
IFile file = project.getFile(".cdtbuild");
private static ManagedBuildInfo loadBuildInfo(IProject project) {
ManagedBuildInfo buildInfo = null;
IFile file = project.getFile(FILE_NAME);
if (!file.exists())
return null;
@ -327,8 +358,8 @@ public class ManagedBuildManager {
DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document document = parser.parse(stream);
Node rootElement = document.getFirstChild();
if (rootElement.getNodeName().equals("buildInfo")) {
buildInfo = new ResourceBuildInfo(project, (Element)rootElement);
if (rootElement.getNodeName().equals(ROOT_ELEM_NAME)) {
buildInfo = new ManagedBuildInfo(project, (Element)rootElement);
project.setSessionProperty(buildInfoProperty, buildInfo);
}
} catch (Exception e) {
@ -338,13 +369,14 @@ public class ManagedBuildManager {
return buildInfo;
}
private static ResourceBuildInfo findBuildInfo(IResource resource, boolean create) {
private static ManagedBuildInfo findBuildInfo(IResource resource, boolean create) {
// Make sure the extension information is loaded first
loadExtensions();
ResourceBuildInfo buildInfo = null;
ManagedBuildInfo buildInfo = null;
try {
buildInfo = (ResourceBuildInfo)resource.getSessionProperty(buildInfoProperty);
buildInfo = (ManagedBuildInfo)resource.getSessionProperty(buildInfoProperty);
} catch (CoreException e) {
return buildInfo;
}
if (buildInfo == null && resource instanceof IProject) {
@ -353,7 +385,7 @@ public class ManagedBuildManager {
if (buildInfo == null && create) {
try {
buildInfo = new ResourceBuildInfo();
buildInfo = new ManagedBuildInfo();
resource.setSessionProperty(buildInfoProperty, buildInfo);
} catch (CoreException e) {
buildInfo = null;
@ -363,12 +395,22 @@ public class ManagedBuildManager {
return buildInfo;
}
public static IResourceBuildInfo getBuildInfo(IResource resource, boolean create) {
return (IResourceBuildInfo) findBuildInfo(resource, create);
public static IManagedBuildInfo getBuildInfo(IResource resource, boolean create) {
return (IManagedBuildInfo) findBuildInfo(resource, create);
}
public static IResourceBuildInfo getBuildInfo(IResource resource) {
return (IResourceBuildInfo) findBuildInfo(resource, false);
public static IManagedBuildInfo getBuildInfo(IResource resource) {
return (IManagedBuildInfo) findBuildInfo(resource, false);
}
/*
* @return
*/
private static Map getBuildModelListeners() {
if (buildModelListeners == null) {
buildModelListeners = new HashMap();
}
return buildModelListeners;
}
/**
@ -378,8 +420,88 @@ public class ManagedBuildManager {
* @param resource
* @return
*/
public static IManagedBuildPathInfo getBuildPathInfo(IResource resource) {
return (IManagedBuildPathInfo) getBuildInfo(resource, false);
private static IScannerInfo getScannerInfo(IResource resource) {
return (IScannerInfo) getBuildInfo(resource, false);
}
/* (non-Javadoc)
* @see org.eclipse.cdt.core.parser.IScannerInfoProvider#subscribe(org.eclipse.cdt.core.parser.IScannerInfoChangeListener)
*/
public synchronized void subscribe(IResource resource, IScannerInfoChangeListener listener) {
IResource project = null;
if (resource instanceof IProject) {
project = resource;
} else if (resource instanceof IFile) {
project = ((IFile)resource).getProject();
} else {
return;
}
// Get listeners for this resource
Map map = getBuildModelListeners();
List list = (List) map.get(project);
if (list == null) {
// Create a new list
list = new ArrayList();
}
if (!list.contains(listener)) {
// Add the new listener for the resource
list.add(listener);
map.put(project, list);
}
}
/* (non-Javadoc)
* @see org.eclipse.cdt.core.parser.IScannerInfoProvider#managesResource(org.eclipse.core.resources.IResource)
*/
public boolean managesResource(IResource resource) {
// The managed build manager manages build information for the
// resource IFF it it is a project and has a build file with the proper
// root element
IProject project = null;
if (resource instanceof IProject){
project = (IProject)resource;
} else if (resource instanceof IFile) {
project = ((IFile)resource).getProject();
} else {
return false;
}
IFile file = project.getFile(FILE_NAME);
if (file.exists()) {
try {
InputStream stream = file.getContents();
DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document document = parser.parse(stream);
Node rootElement = document.getFirstChild();
if (rootElement.getNodeName().equals(ROOT_ELEM_NAME)) {
return true;
}
} catch (Exception e) {
return false;
}
}
return false;
}
/* (non-Javadoc)
* @see org.eclipse.cdt.core.parser.IScannerInfoProvider#unsubscribe(org.eclipse.cdt.core.parser.IScannerInfoChangeListener)
*/
public synchronized void unsubscribe(IResource resource, IScannerInfoChangeListener listener) {
IResource project = null;
if (resource instanceof IProject) {
project = resource;
} else if (resource instanceof IFile) {
project = ((IFile)resource).getProject();
} else {
return;
}
// Remove the listener
Map map = getBuildModelListeners();
List list = (List) map.get(project);
if (list != null && !list.isEmpty()) {
// The list is not empty so try to remove listener
list.remove(listener);
map.put(project, list);
}
}
}

308
core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/standard/StandardBuildManager.java Normal file
View file

@ -0,0 +1,308 @@
package org.eclipse.cdt.core.build.standard;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.apache.xerces.dom.DocumentImpl;
import org.apache.xml.serialize.Method;
import org.apache.xml.serialize.OutputFormat;
import org.apache.xml.serialize.Serializer;
import org.apache.xml.serialize.SerializerFactory;
import org.eclipse.cdt.core.BuildInfoFactory;
import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.parser.IScannerInfo;
import org.eclipse.cdt.core.parser.IScannerInfoChangeListener;
import org.eclipse.cdt.core.parser.IScannerInfoProvider;
import org.eclipse.cdt.core.resources.IStandardBuildInfo;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.QualifiedName;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
/**********************************************************************
* Copyright (c) 2002,2003 Rational Software Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v0.5
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v05.html
*
* Contributors:
* IBM Rational Software - Initial API and implementation
***********************************************************************/
public class StandardBuildManager implements IScannerInfoProvider {
// Name we will use to store build property with the project
private static final QualifiedName buildInfoProperty
= new QualifiedName(CCorePlugin.PLUGIN_ID, "standardBuildInfo");
// Listeners interested in build model changes
private static Map buildModelListeners;
private static final String FILE_NAME = ".cdtbuild";
private static final String ROOT_ELEM_NAME = "StandardProjectBuildInfo";
/**
* @param project
* @return
*/
private static IStandardBuildInfo findBuildInfo(IResource resource, boolean create) {
IStandardBuildInfo buildInfo = null;
// See if there's already one associated with the resource for this session
try {
buildInfo = (IStandardBuildInfo)resource.getSessionProperty(buildInfoProperty);
} catch (CoreException e) {
return buildInfo;
}
// Try to load one for the project
if (buildInfo == null && resource instanceof IProject) {
buildInfo = loadBuildInfo((IProject)resource);
}
// There is nothing persisted for the session, or saved in a file so
// create a build info object
if (buildInfo == null && create) {
buildInfo = BuildInfoFactory.create((IProject)resource);
try {
((IProject)resource).setSessionProperty(buildInfoProperty, buildInfo);
} catch (CoreException e) {
buildInfo = null;
}
}
return buildInfo;
}
public static IStandardBuildInfo getBuildInfo(IProject project) {
return findBuildInfo(project, false);
}
public static IStandardBuildInfo getBuildInfo(IProject project, boolean create) {
return findBuildInfo(project, create);
}
/*
* @return
*/
private static synchronized Map getBuildModelListeners() {
if (buildModelListeners == null) {
buildModelListeners = new HashMap();
}
return buildModelListeners;
}
/* (non-Javadoc)
* @see org.eclipse.cdt.core.parser.IScannerInfoProvider#managesResource(org.eclipse.core.resources.IResource)
*/
public boolean managesResource(IResource resource) {
/*
* Answers true if this project has a build info associated with it
*/
IProject project = null;
if (resource instanceof IProject) {
project = (IProject)resource;
} else if (resource instanceof IFile) {
project = ((IFile)resource).getProject();
} else {
return false;
}
// Look for (but do not create) the build information
IStandardBuildInfo info = getBuildInfo(project);
// If there's info, I manage the resource
return info == null ? false : true;
}
public static void setPreprocessorSymbols(IProject project, String[] symbols) {
// Get the information for the project
IStandardBuildInfo info = getBuildInfo(project);
// Set the new information
if (info != null) {
String[] oldSymbols = info.getPreprocessorSymbols();
if (!Arrays.equals(oldSymbols, symbols)) {
info.setPreprocessorSymbols(symbols);
// Alert the listeners
setScannerInfoDirty(project, info);
}
}
}
public static void setIncludePaths(IProject project, String[] paths) {
// Get the build info for the project
IStandardBuildInfo info = getBuildInfo(project);
if (info != null) {
String[] oldPaths = info.getIncludePaths();
if (!Arrays.equals(oldPaths, paths)) {
info.setIncludePaths(paths);
setScannerInfoDirty(project, info);
}
}
}
/**
* @param project
* @param info
*/
private static void setScannerInfoDirty(IProject project, IStandardBuildInfo info) {
// Call in the cavalry
List listeners = (List) getBuildModelListeners().get(project);
if (listeners == null) {
return;
}
ListIterator iter = listeners.listIterator();
while (iter.hasNext()) {
((IScannerInfoChangeListener)iter.next()).changeNotification(project, (IScannerInfo) info);
}
}
/*
* Loads the build file and parses the nodes for build information. The
* information is then associated with the resource for the duration of
* the session.
*/
private static IStandardBuildInfo loadBuildInfo(IProject project) {
IStandardBuildInfo buildInfo = null;
IFile file = project.getFile(FILE_NAME);
if (!file.exists())
return null;
try {
InputStream stream = file.getContents();
DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document document = parser.parse(stream);
Node rootElement = document.getFirstChild();
if (rootElement.getNodeName().equals(ROOT_ELEM_NAME)) {
buildInfo = BuildInfoFactory.create(project, (Element)rootElement);
project.setSessionProperty(buildInfoProperty, buildInfo);
}
} catch (Exception e) {
buildInfo = null;
}
return buildInfo;
}
/**
* The build model manager for standard builds only caches the build
* information for a resource on a per-session basis. This method
* allows clients of the build model manager to programmatically
* remove the association between the resource and the information
* while the reource is still open or in the workspace. The Eclipse core
* will take care of removing it if a resource is closed or deleted.
*
* @param resource
*/
public static void removeBuildInfo(IResource resource) {
try {
resource.setSessionProperty(buildInfoProperty, null);
} catch (CoreException e) {
}
}
/**
* Persists build-specific information in the build file. Build
* information for standard make projects consists of preprocessor
* symbols and includes paths. Other project-related information is
* stored in the persistent properties of the project.
*
* @param project
*/
public static void saveBuildInfo(IProject project) {
// Create document
Document doc = new DocumentImpl();
Element rootElement = doc.createElement(ROOT_ELEM_NAME);
doc.appendChild(rootElement);
// Save the build info
IStandardBuildInfo buildInfo = getBuildInfo(project);
if (buildInfo != null)
buildInfo.serialize(doc, rootElement);
// Save the document
ByteArrayOutputStream s = new ByteArrayOutputStream();
OutputFormat format = new OutputFormat();
format.setIndenting(true);
format.setLineSeparator(System.getProperty("line.separator")); //$NON-NLS-1$
String xml = null;
try {
Serializer serializer = SerializerFactory.getSerializerFactory(Method.XML).makeSerializer(new OutputStreamWriter(s, "UTF8"), format);
serializer.asDOMSerializer().serialize(doc);
xml = s.toString("UTF8"); //$NON-NLS-1$
IFile rscFile = project.getFile(FILE_NAME);
InputStream inputStream = new ByteArrayInputStream(xml.getBytes());
// update the resource content
if (rscFile.exists()) {
rscFile.setContents(inputStream, IResource.FORCE, null);
} else {
rscFile.create(inputStream, IResource.FORCE, null);
}
} catch (Exception e) {
return;
}
}
/* (non-Javadoc)
* @see org.eclipse.cdt.core.parser.IScannerInfoProvider#subscribe(org.eclipse.core.resources.IResource, org.eclipse.cdt.core.parser.IScannerInfoChangeListener)
*/
public synchronized void subscribe(IResource resource, IScannerInfoChangeListener listener) {
IResource project = null;
if (resource instanceof IProject) {
project = resource;
} else if (resource instanceof IFile) {
project = ((IFile)resource).getProject();
} else {
return;
}
// Get listeners for this resource
Map map = getBuildModelListeners();
List list = (List) map.get(project);
if (list == null) {
// Create a new list
list = new ArrayList();
}
if (!list.contains(listener)) {
// Add the new listener for the resource
list.add(listener);
map.put(project, list);
}
}
/* (non-Javadoc)
* @see org.eclipse.cdt.core.parser.IScannerInfoProvider#unsubscribe(org.eclipse.core.resources.IResource, org.eclipse.cdt.core.parser.IScannerInfoChangeListener)
*/
public synchronized void unsubscribe(IResource resource, IScannerInfoChangeListener listener) {
IResource project = null;
if (resource instanceof IProject) {
project = resource;
} else if (resource instanceof IFile) {
project = ((IFile)resource).getProject();
} else {
return;
}
// Remove the listener
Map map = getBuildModelListeners();
List list = (List) map.get(project);
if (list != null && !list.isEmpty()) {
// The list is not empty so try to remove listener
list.remove(listener);
map.put(project, list);
}
}
}

42
core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/ResourceBuildInfo.java → core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/ManagedBuildInfo.java
View file

@ -19,18 +19,18 @@ import java.util.ListIterator;
import java.util.Map;
import org.eclipse.cdt.core.build.managed.BuildException;
import org.eclipse.cdt.core.build.managed.IManagedBuildPathInfo;
import org.eclipse.cdt.core.build.managed.IConfiguration;
import org.eclipse.cdt.core.build.managed.IOption;
import org.eclipse.cdt.core.build.managed.IResourceBuildInfo;
import org.eclipse.cdt.core.build.managed.IManagedBuildInfo;
import org.eclipse.cdt.core.build.managed.ITarget;
import org.eclipse.cdt.core.build.managed.ITool;
import org.eclipse.cdt.core.parser.IScannerInfo;
import org.eclipse.core.resources.IResource;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
public class ResourceBuildInfo implements IResourceBuildInfo, IManagedBuildPathInfo {
public class ManagedBuildInfo implements IManagedBuildInfo, IScannerInfo {
private IResource owner;
private Map targetMap;
@ -38,13 +38,13 @@ public class ResourceBuildInfo implements IResourceBuildInfo, IManagedBuildPathI
private Map defaultConfigurations;
private ITarget defaultTarget;
public ResourceBuildInfo() {
public ManagedBuildInfo() {
targetMap = new HashMap();
targets = new ArrayList();
defaultConfigurations = new HashMap();
}
public ResourceBuildInfo(IResource owner, Element element) {
public ManagedBuildInfo(IResource owner, Element element) {
this();
// The id of the default configuration
String defaultTargetId = null;
@ -277,11 +277,11 @@ public class ResourceBuildInfo implements IResourceBuildInfo, IManagedBuildPathI
}
/* (non-Javadoc)
* @see org.eclipse.cdt.core.build.managed.IBuildParseInfo#getDefinedSymbols()
* @see org.eclipse.cdt.core.build.managed.IScannerInfo#getDefinedSymbols()
*/
public String[] getDefinedSymbols() {
// Return the include paths for the default configuration
ArrayList paths = new ArrayList();
public Map getDefinedSymbols() {
// Return the defined symbols for the default configuration
HashMap symbols = new HashMap();
IConfiguration config = getDefaultConfiguration(getDefaultTarget());
ITool[] tools = config.getTools();
for (int i = 0; i < tools.length; i++) {
@ -291,7 +291,24 @@ public class ResourceBuildInfo implements IResourceBuildInfo, IManagedBuildPathI
IOption option = opts[j];
if (option.getValueType() == IOption.PREPROCESSOR_SYMBOLS) {
try {
paths.addAll(Arrays.asList(option.getDefinedSymbols()));
String[] symbolList = option.getDefinedSymbols();
for (int k = 0; k < symbolList.length; k++) {
String symbol = symbolList[k];
if (symbol.length() == 0){
continue;
}
String key = new String();
String value = new String();
int index = symbol.indexOf("=");
if (index != -1) {
key = symbol.substring(0, index).trim();
value = symbol.substring(index + 1).trim();
} else {
key = symbol.trim();
}
symbols.put(key, value);
}
} catch (BuildException e) {
// we should never get here
continue;
@ -299,12 +316,11 @@ public class ResourceBuildInfo implements IResourceBuildInfo, IManagedBuildPathI
}
}
}
paths.trimToSize();
return (String[])paths.toArray(new String[paths.size()]);
return symbols;
}
/* (non-Javadoc)
* @see org.eclipse.cdt.core.build.managed.IBuildParseInfo#getIncludePaths()
* @see org.eclipse.cdt.core.build.managed.IScannerInfo#getIncludePaths()
*/
public String[] getIncludePaths() {
// Return the include paths for the default configuration

6
core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/Target.java
View file

@ -16,7 +16,7 @@ import java.util.List;
import java.util.Map;
import org.eclipse.cdt.core.build.managed.IConfiguration;
import org.eclipse.cdt.core.build.managed.IResourceBuildInfo;
import org.eclipse.cdt.core.build.managed.IManagedBuildInfo;
import org.eclipse.cdt.core.build.managed.ITarget;
import org.eclipse.cdt.core.build.managed.ITool;
import org.eclipse.cdt.core.build.managed.ManagedBuildManager;
@ -68,7 +68,7 @@ public class Target extends BuildObject implements ITarget {
this.isTest = parent.isTestTarget();
// Hook me up
IResourceBuildInfo buildInfo = ManagedBuildManager.getBuildInfo(owner, true);
IManagedBuildInfo buildInfo = ManagedBuildManager.getBuildInfo(owner, true);
buildInfo.addTarget(this);
}
@ -129,7 +129,7 @@ public class Target extends BuildObject implements ITarget {
* @param buildInfo
* @param element
*/
public Target(ResourceBuildInfo buildInfo, Element element) {
public Target(ManagedBuildInfo buildInfo, Element element) {
this(buildInfo.getOwner());
// id

19
core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IManagedBuildPathInfo.java → core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfo.java
View file

@ -1,4 +1,6 @@
package org.eclipse.cdt.core.build.managed;
package org.eclipse.cdt.core.parser;
import java.util.Map;
/**********************************************************************
* Copyright (c) 2002,2003 Rational Software Corporation and others.
@ -11,15 +13,20 @@ package org.eclipse.cdt.core.build.managed;
* IBM Rational Software - Initial API and implementation
***********************************************************************/
public interface IManagedBuildPathInfo {
public interface IScannerInfo {
/**
* Answers a <code>String</code> array containing all the defined
* preprocessor symbols. If there are no defined symbols, the receiver
* will return an empty array, never <code>null</code>
* Answers a <code>Map</code> containing all the defined preprocessor
* symbols and their values as string tuples, (symbol_name, symbol_value).
* Symbols defined without values have an empty string for a value. For
* example,-Dsymbol=value would have a map entry (symbol,value). A symbol
* defined as -Dsymbol would have a map entry of (symbol,"").
*
* If there are no defined symbols, the receiver will return
* an empty Map, never <code>null</code>.
*
* @return
*/
public String[] getDefinedSymbols();
public Map getDefinedSymbols();
/**
* Answers a <code>String</code> array containing all the known include

26
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfoChangeListener.java Normal file
View file

@ -0,0 +1,26 @@
package org.eclipse.cdt.core.parser;
import org.eclipse.core.resources.IResource;
/**********************************************************************
* Copyright (c) 2002,2003 Rational Software Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v0.5
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v05.html
*
* Contributors:
* IBM Rational Software - Initial API and implementation
***********************************************************************/
public interface IScannerInfoChangeListener {
/**
* The listener must implement this method in order to receive the new
* information from the provider.
*
* @param info
*/
public void changeNotification(IResource project, IScannerInfo info);
}

44
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfoProvider.java Normal file
View file

@ -0,0 +1,44 @@
package org.eclipse.cdt.core.parser;
import org.eclipse.core.resources.IResource;
/**********************************************************************
* Copyright (c) 2002,2003 Rational Software Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v0.5
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v05.html
*
* Contributors:
* IBM Rational Software - Initial API and implementation
***********************************************************************/
public interface IScannerInfoProvider {
/**
* The receiver will register the listener specified in the argument
* to receive change notifications when the information for the
* <code>IResource</code> it is responsible for changes.
*
* @param listener
*/
public void subscribe(IResource resource, IScannerInfoChangeListener listener);
/**
* Answers <code>true</code> if the receiver has information for
* the resource specified in the argument, else <code>false</code>.
*
* @param resource
* @return
*/
public boolean managesResource(IResource resource);
/**
* The receiver will no longer notify the listener specified in
* the argument when information about the reource it is responsible
* for changes.
*
* @param listener
*/
public void unsubscribe(IResource resource, IScannerInfoChangeListener listener);
}

14
core/org.eclipse.cdt.core/plugin.xml
View file

@ -33,6 +33,7 @@
<extension-point id="CBuildVariable" name="C/C++ Build Variable" schema="schema/CBuildVariable.exsd"/>
<extension-point id="CToolType" name="C/C++ Tool Type" schema="schema/CToolType.exsd"/>
<extension-point id="ManagedBuildInfo" name="Managed Build Tools" schema="schema/ManagedBuildTools.exsd"/>
<extension-point id="ScannerInfoProvider" name="Scanner Information Provider" schema="schema/ScannerInfoProvider.exsd"/>
<extension
point="org.eclipse.cdt.core.CToolType">
@ -279,6 +280,19 @@
pattern="*.exe">
</ignore>
</extension>
<extension
id="org.eclipse.cdt.core.ScannerInfoProvider"
name="Scanner Information Provider"
point="org.eclipse.cdt.core.ScannerInfoProvider">
<provider
class="org.eclipse.cdt.core.build.managed.ManagedBuildManager"
id="org.eclipse.cdt.core.provider.managed">
</provider>
<provider
class="org.eclipse.cdt.core.build.standard.StandardBuildManager"
id="org.eclipse.cdt.core.provider.standard">
</provider>
</extension>
<extension id="task" name="%CTaskName" point="org.eclipse.core.resources.markers">
<super type="org.eclipse.core.resources.taskmarker"/>

2
core/org.eclipse.cdt.core/schema/ManagedBuildTools.exsd
View file

@ -393,7 +393,7 @@ Two additional types exist to flag options of special relevance to the build mod
<meta.section type="since"/>
</appInfo>
<documentation>
CDT 1.1
1.2
</documentation>
</annotation>

121
core/org.eclipse.cdt.core/schema/ScannerInfoProvider.exsd Normal file
View file

@ -0,0 +1,121 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.cdt.core">
<annotation>
<appInfo>
<meta.schema plugin="org.eclipse.cdt.core" id="ScannerInfoProvider" name="Scanner Information Provider"/>
</appInfo>
<documentation>
This extension point provides a mechanism for the clients of the scanner to discover providers of information the scanner requires to function properly. This information is usually provided by a build system.
</documentation>
</annotation>
<element name="extension">
<complexType>
<sequence>
<element ref="provider" minOccurs="1" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
<documentation>
</documentation>
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
<documentation>
</documentation>
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
<documentation>
</documentation>
</annotation>
</attribute>
</complexType>
</element>
<element name="provider">
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
<documentation>
A unique name that will be used to reference this parser.
</documentation>
</annotation>
</attribute>
<attribute name="class" type="string">
<annotation>
<documentation>
A fully qualified name of the Java class that implements &lt;samp&gt;org.eclipse.cdt.core.parser.IScannerProviderInfo&lt;/samp&gt; interface
</documentation>
<appInfo>
<meta.attribute kind="java" basedOn="org.eclipse.cdt.core.parser.IScannerProviderInfo"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="since"/>
</appInfo>
<documentation>
1.2
</documentation>
</annotation>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
<documentation>
[Enter extension point usage example here.]
</documentation>
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
<documentation>
The following is an example of the extension point usage:
&lt;p&gt;
&lt;pre&gt;
&lt;extension
id=&quot;org.eclipse.cdt.core.ScannerInfoProvider&quot;
name=&quot;Scanner Information Provider&quot;
point=&quot;org.eclipse.cdt.core.ScannerInfoProvider&quot;&gt;
&lt;provider
id=&quot;org.eclipse.cdt.core.provider.managed&quot;
class=&quot;org.eclipse.cdt.core.build.managed.ManagedBuildManager&quot;&gt;
&lt;/provider&gt;
&lt;/extension&gt;
&lt;/pre&gt;
</documentation>
</annotation>
<annotation>
<appInfo>
<meta.section type="implementation"/>
</appInfo>
<documentation>
[Enter information about supplied implementation of this extension point.]
</documentation>
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
<documentation>
</documentation>
</annotation>
</schema>

137
core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/BuildInfoFactory.java
View file

@ -6,6 +6,15 @@ package org.eclipse.cdt.core;
*/
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import org.eclipse.cdt.core.parser.IScannerInfo;
import org.eclipse.cdt.core.resources.IStandardBuildInfo;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
@ -15,8 +24,9 @@ import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.cdt.core.resources.IBuildInfo;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
public class BuildInfoFactory {
public static final String LOCATION = "buildLocation";
@ -25,10 +35,17 @@ public class BuildInfoFactory {
public static final String STOP_ON_ERROR = "stopOnError";
// public static final String CLEAR_CONSOLE = "clearConsole";
public static final String DEFAULT_BUILD_CMD = "useDefaultBuildCmd";
public static final String INCLUDE_PATHS = "includePaths";
public static final String DEFINED_SYMBOLS = "definedSymbols";
public static final String PROJECT_NAME = "projectName";
public static final String INCLUDE_PATH = "includePath";
public static final String PATH = "path";
public static final String DEFINED_SYMBOL = "definedSymbol";
public static final String SYMBOL = "symbol";
public static abstract class Store implements IStandardBuildInfo, IScannerInfo {
// List of include paths
protected List pathList;
protected List symbolList;
public static abstract class Store implements IBuildInfo {
public String getBuildLocation() {
if ( isDefaultBuildCmd() ) {
Plugin plugin = CCorePlugin.getDefault();
@ -51,16 +68,41 @@ public class BuildInfoFactory {
return getString(LOCATION);
}
public String getDefinedSymbols() {
return getString(DEFINED_SYMBOLS);
/* (non-Javadoc)
* @see org.eclipse.cdt.core.build.managed.IScannerInfo#getIncludePaths()
*/
public Map getDefinedSymbols() {
// Return the defined symbols for the default configuration
HashMap symbols = new HashMap();
String[] symbolList = getPreprocessorSymbols();
for (int i = 0; i < symbolList.length; ++i) {
String symbol = symbolList[i];
if (symbol.length() == 0) {
continue;
}
String key = new String();
String value = new String();
int index = symbol.indexOf("=");
if (index != -1) {
key = symbol.substring(0, index).trim();
value = symbol.substring(index + 1).trim();
} else {
key = symbol.trim();
}
symbols.put(key, value);
}
return symbols;
}
public String getFullBuildArguments() {
return getString(FULL_ARGUMENTS);
}
public String getIncludePaths() {
return getString(INCLUDE_PATHS);
/* (non-Javadoc)
* @see org.eclipse.cdt.core.build.managed.IScannerInfo#getIncludePaths()
*/
public String[] getIncludePaths() {
return (String[]) getPathList().toArray(new String[getPathList().size()]);
}
public String getIncrementalBuildArguments() {
@ -75,16 +117,20 @@ public class BuildInfoFactory {
putValue(LOCATION, location);
}
public void setDefinedSymbols(String argument) {
putValue(DEFINED_SYMBOLS, argument);
public void setPreprocessorSymbols(String[] symbols) {
// Clear out any existing symbols and add the new stuff
getSymbolList().clear();
getSymbolList().addAll(Arrays.asList(symbols));
}
public void setFullBuildArguments(String arguments) {
putValue(FULL_ARGUMENTS, arguments);
}
public void setIncludePaths(String arguments) {
putValue(INCLUDE_PATHS, arguments);
public void setIncludePaths(String[] paths) {
// Clear the existing list and add the paths
getPathList().clear();
getPathList().addAll(Arrays.asList(paths));
}
public void setIncrementalBuildArguments(String arguments) {
@ -117,10 +163,48 @@ public class BuildInfoFactory {
public void putValue(String name, String value) {
}
/* (non-Javadoc)
* @see org.eclipse.cdt.core.resources.IBuildInfo#serialize(org.w3c.dom.Document, org.w3c.dom.Element)
*/
public void serialize(Document doc, Element rootElement) {
// Serialize the include paths
ListIterator iter = getPathList().listIterator();
while (iter.hasNext()){
Element pathElement = doc.createElement(INCLUDE_PATH);
pathElement.setAttribute(PATH, (String)iter.next());
rootElement.appendChild(pathElement);
}
// Now do the same for the symbols
iter = getSymbolList().listIterator();
while (iter.hasNext()) {
Element symbolElement = doc.createElement(DEFINED_SYMBOL);
symbolElement.setAttribute(SYMBOL, (String)iter.next());
rootElement.appendChild(symbolElement);
}
}
protected List getPathList() {
if (pathList == null) {
pathList = new ArrayList();
}
return pathList;
}
public String getString(String property) {
return null;
}
public String[] getPreprocessorSymbols() {
return (String[]) getSymbolList().toArray(new String[getSymbolList().size()]);
}
protected List getSymbolList() {
if (symbolList == null) {
symbolList = new ArrayList();
}
return symbolList;
}
}
public static class Preference extends Store {
@ -170,17 +254,40 @@ public class BuildInfoFactory {
public void setDefault(String name, String def) {
}
// public boolean isClearBuildConsole() {
// return (new Preference()).isClearBuildConsole();
// }
}
public static IBuildInfo create() {
public static IStandardBuildInfo create() {
return new BuildInfoFactory.Preference();
}
public static IBuildInfo create(IProject project) {
public static IStandardBuildInfo create(IProject project) {
return new BuildInfoFactory.Property(project);
}
/**
* @param project
* @param element
* @return
*/
public static IStandardBuildInfo create(IProject project, Element element) {
// Create a new info property object
Property buildProperties = new Property(project);
Node child = element.getFirstChild();
while (child != null) {
if (child.getNodeName().equals(INCLUDE_PATH)) {
// Add the path to the property list
buildProperties.getPathList().add(((Element)child).getAttribute(PATH));
} else if (child.getNodeName().equals(DEFINED_SYMBOL)) {
// Add the symbol to the symbol list
buildProperties.getSymbolList().add(((Element)child).getAttribute(SYMBOL));
}
child = child.getNextSibling();
}
return (IStandardBuildInfo)buildProperties;
}
}

60
core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/CProjectNature.java
View file

@ -9,7 +9,8 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.eclipse.cdt.core.resources.IBuildInfo;
import org.eclipse.cdt.core.build.standard.StandardBuildManager;
import org.eclipse.cdt.core.resources.IStandardBuildInfo;
import org.eclipse.core.resources.ICommand;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
@ -30,7 +31,7 @@ public class CProjectNature implements IProjectNature {
public static final String C_NATURE_ID= CCorePlugin.PLUGIN_ID + ".cnature";
private IProject fProject;
private IBuildInfo fBuildInfo;
private IStandardBuildInfo fBuildInfo;
public CProjectNature() {
}
@ -106,30 +107,6 @@ public class CProjectNature implements IProjectNature {
return new Path(buildLocation);
}
/**
* Answers a comma-separated list of defined preprocessor symbols
* for the project, or an empty string if there are none.
*
* @return
* @throws CoreException
*/
public String getDefinedSymbols() throws CoreException {
String symbols = fBuildInfo.getDefinedSymbols();
return symbols == null ? new String() : symbols;
}
/**
* Sets the defined symbols for the project.
*
* @param symbols
*/
public void setDefinedSymbols(String symbols, IProgressMonitor monitor) throws CoreException {
String oldSymbols = fBuildInfo.getDefinedSymbols();
if (symbols != null && !symbols.equals(oldSymbols)) {
fBuildInfo.setDefinedSymbols(symbols);
}
}
/**
* Sets the arguments for the full build.
*/
@ -151,32 +128,6 @@ public class CProjectNature implements IProjectNature {
return buildArguments;
}
/**
* Answers a comma-separated list of include paths defined for
* the project, or an empty string if there are none.
*
* @return
* @throws CoreException
*/
public String getIncludePaths() throws CoreException {
String paths = fBuildInfo.getIncludePaths();
return paths == null ? new String() : paths;
}
/**
* Sets the include path information for the project.
*
* @param paths
* @param monitor
* @throws CoreException
*/
public void setIncludePaths(String paths, IProgressMonitor monitor) throws CoreException {
String oldPaths = fBuildInfo.getIncludePaths();
if (paths != null && !paths.equals(oldPaths)) {
fBuildInfo.setIncludePaths(paths);
}
}
/**
* Sets the arguments for the incremental build.
*/
@ -318,7 +269,7 @@ public class CProjectNature implements IProjectNature {
*/
public void configure() throws CoreException {
addToBuildSpec(getBuilderID(), null);
IBuildInfo info = BuildInfoFactory.create();
IStandardBuildInfo info = BuildInfoFactory.create();
fBuildInfo.setBuildLocation(info.getBuildLocation());
fBuildInfo.setFullBuildArguments("");
fBuildInfo.setIncrementalBuildArguments("");
@ -346,6 +297,7 @@ public class CProjectNature implements IProjectNature {
*/
public void setProject(IProject project) {
fProject= project;
fBuildInfo = BuildInfoFactory.create(fProject);
fBuildInfo = StandardBuildManager.getBuildInfo(fProject, true);
}
}

24
core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/resources/IBuildInfo.java → core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/resources/IStandardBuildInfo.java
View file

@ -1,30 +1,38 @@
package org.eclipse.cdt.core.resources;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
/*
* (c) Copyright QNX Software Systems Ltd. 2002.
* All Rights Reserved.
*/
public interface IBuildInfo {
public static final String SEPARATOR = ",";
public interface IStandardBuildInfo {
String getBuildLocation();
String getDefinedSymbols();
public String[] getPreprocessorSymbols();
String getFullBuildArguments();
String getIncludePaths();
public String[] getIncludePaths();
String getIncrementalBuildArguments();
boolean isStopOnError();
void setBuildLocation(String location);
void setDefinedSymbols(String symbols);
public void setPreprocessorSymbols(String[] symbols);
void setFullBuildArguments(String arguments);
void setIncludePaths(String paths);
void setIncrementalBuildArguments(String arguments);
public void setIncludePaths(String[] paths);
void setIncrementalBuildArguments(String arguments);
void setStopOnError(boolean on);
// boolean isClearBuildConsole();
boolean isDefaultBuildCmd();
void setUseDefaultBuildCmd(boolean on);
/**
* @param doc
* @param rootElement
*/
void serialize(Document doc, Element rootElement);
}

16
core/org.eclipse.cdt.core/src/org/eclipse/cdt/internal/core/GeneratedMakefileBuilder.java
View file

@ -14,7 +14,7 @@ package org.eclipse.cdt.internal.core;
import java.io.ByteArrayInputStream;
import java.util.Map;
import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.build.managed.IResourceBuildInfo;
import org.eclipse.cdt.core.build.managed.IManagedBuildInfo;
import org.eclipse.cdt.core.build.managed.ManagedBuildManager;
import org.eclipse.cdt.core.resources.ACBuilder;
import org.eclipse.cdt.core.resources.MakeUtil;
@ -72,14 +72,14 @@ public class GeneratedMakefileBuilder extends ACBuilder {
*
* @param buffer
*/
private void addMacros(StringBuffer buffer, IResourceBuildInfo info) {
private void addMacros(StringBuffer buffer, IManagedBuildInfo info) {
// TODO this should come from the build model
buffer.append("RM = rm -f" + NEWLINE);
buffer.append("MAKE = make" + NEWLINE);
buffer.append(NEWLINE);
}
private void addRule(StringBuffer buffer, IPath sourcePath, String outputName, IResourceBuildInfo info) {
private void addRule(StringBuffer buffer, IPath sourcePath, String outputName, IManagedBuildInfo info) {
// Add the rule to the makefile
buffer.append(outputName + COLON + " " + sourcePath.toString());
// Add all of the dependencies on the source file
@ -96,7 +96,7 @@ public class GeneratedMakefileBuilder extends ACBuilder {
*
* @param buffer
*/
private void addSources(StringBuffer buffer, IResourceBuildInfo info) throws CoreException {
private void addSources(StringBuffer buffer, IManagedBuildInfo info) throws CoreException {
// Add the list of project files to be built
buffer.append("OBJS = \\" + NEWLINE);
@ -133,7 +133,7 @@ public class GeneratedMakefileBuilder extends ACBuilder {
/**
* @param buffer
*/
private void addTargets(StringBuffer buffer, IResourceBuildInfo info) {
private void addTargets(StringBuffer buffer, IManagedBuildInfo info) {
// Generate a rule per source
// This is the top build rule
@ -270,9 +270,7 @@ public class GeneratedMakefileBuilder extends ACBuilder {
monitor.subTask(statusMsg);
// Get a filehandle for the makefile
IPath filePath = getWorkingDirectory();
filePath.addTrailingSeparator();
filePath.append(FILENAME);
IPath filePath = getWorkingDirectory().append(IPath.SEPARATOR + FILENAME);
IFile fileHandle = getMakefile(filePath, monitor);
// Now populate it
@ -289,7 +287,7 @@ public class GeneratedMakefileBuilder extends ACBuilder {
private void populateMakefile(IFile fileHandle, IProgressMonitor monitor) throws CoreException {
// Write out the contents of the build model
StringBuffer buffer = new StringBuffer();
IResourceBuildInfo info = ManagedBuildManager.getBuildInfo(getProject());
IManagedBuildInfo info = ManagedBuildManager.getBuildInfo(getProject());
// Add the macro definitions
addMacros(buffer, info);

6
core/org.eclipse.cdt.ui/ChangeLog
View file

@ -1,3 +1,9 @@
2003-07-03 Sean Evoy
Changed property/wizard tab to use the new StandardBuildManager and
the improved IStandardBuildInfo interface to set and retrieve
the include and defined symbol information for a standard make project.
* src/org/eclipse/cdt/ui/wizards/BuildPathInfoBlock.java
2003-06-27 Andrew Niefer
Changes for C/C++ Search:
Added:

82
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/ui/wizards/BuildPathInfoBlock.java
View file

@ -1,9 +1,7 @@
package org.eclipse.cdt.ui.wizards;
import java.util.StringTokenizer;
import org.eclipse.cdt.core.CProjectNature;
import org.eclipse.cdt.core.resources.IBuildInfo;
import org.eclipse.cdt.core.build.standard.StandardBuildManager;
import org.eclipse.cdt.core.resources.IStandardBuildInfo;
import org.eclipse.cdt.internal.ui.util.SWTUtil;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.utils.ui.controls.ControlFactory;
@ -263,23 +261,19 @@ public class BuildPathInfoBlock implements IWizardTab {
* @see org.eclipse.cdt.ui.wizards.IWizardTab#doRun(org.eclipse.core.resources.IProject, org.eclipse.core.runtime.IProgressMonitor)
*/
public void doRun(IProject project, IProgressMonitor monitor) {
try {
if (monitor == null) {
monitor = new NullProgressMonitor();
}
// Store the paths and symbols as comma-separated lists in the project's nature
CProjectNature nature = (CProjectNature) project.getNature(CProjectNature.C_NATURE_ID);
if (monitor == null) {
monitor = new NullProgressMonitor();
}
if (project != null) {
// Store the paths and symbols
monitor.beginTask("Setting Include Paths", 1);
String paths = getPathListContents();
nature.setIncludePaths(paths, monitor);
StandardBuildManager.setIncludePaths(project, getPathListContents());
monitor.beginTask("Setting Defined Symbols", 1);
String symbols = getSymbolListContents();
nature.setDefinedSymbols(symbols, monitor);
StandardBuildManager.setPreprocessorSymbols(project, getSymbolListContents());
StandardBuildManager.saveBuildInfo(project);
}
catch (CoreException e) {
}
}
/*
@ -418,33 +412,15 @@ public class BuildPathInfoBlock implements IWizardTab {
/**
* @return
*/
private String getPathListContents() {
// Convert the contents of the path list into a comma-separated list
StringBuffer buffer = new StringBuffer();
if (pathList != null) {
String[] paths = pathList.getItems();
for (int i = 0; i < paths.length; i++) {
String string = paths[i];
buffer.append(string + IBuildInfo.SEPARATOR);
}
}
return buffer.toString();
private String[] getPathListContents() {
return pathList.getItems();
}
/**
* @return
*/
private String getSymbolListContents() {
// Convert the contents of the symbol list into a comma-separated list
StringBuffer buffer = new StringBuffer();
if (symbolList != null) {
String[] symbols = symbolList.getItems();
for (int i = 0; i < symbols.length; i++) {
String symbol = symbols[i];
buffer.append(symbol + IBuildInfo.SEPARATOR);
}
}
return buffer.toString();
private String[] getSymbolListContents() {
return symbolList.getItems();
}
/**
@ -613,35 +589,15 @@ public class BuildPathInfoBlock implements IWizardTab {
private void setPathListContents() {
if (project != null) {
try {
CProjectNature nature = (CProjectNature)project.getNature(CProjectNature.C_NATURE_ID);
if (nature != null) {
String paths = nature.getIncludePaths();
StringTokenizer tokens = new StringTokenizer(paths, IBuildInfo.SEPARATOR);
while (tokens.hasMoreTokens()) {
pathList.add(tokens.nextToken());
}
}
} catch (CoreException e) {
// Just have an empty list
}
IStandardBuildInfo info = StandardBuildManager.getBuildInfo(project);
pathList.setItems(info.getIncludePaths());
}
}
private void setSymbolListContents() {
if (project != null) {
try {
CProjectNature nature = (CProjectNature)project.getNature(CProjectNature.C_NATURE_ID);
if (nature != null) {
String symbols = nature.getDefinedSymbols();
StringTokenizer tokens = new StringTokenizer(symbols, IBuildInfo.SEPARATOR);
while (tokens.hasMoreTokens()) {
symbolList.add(tokens.nextToken());
}
}
} catch (CoreException e) {
// Just have an empty list
}
IStandardBuildInfo info = StandardBuildManager.getBuildInfo(project);
symbolList.setItems(info.getPreprocessorSymbols());
}
}