diff --git a/core/org.eclipse.cdt.core.tests/ChangeLog b/core/org.eclipse.cdt.core.tests/ChangeLog index 5b785d5d222..9a07c0e8b09 100644 --- a/core/org.eclipse.cdt.core.tests/ChangeLog +++ b/core/org.eclipse.cdt.core.tests/ChangeLog @@ -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. diff --git a/core/org.eclipse.cdt.core.tests/build/org/eclipse/cdt/core/build/managed/tests/AllBuildTests.java b/core/org.eclipse.cdt.core.tests/build/org/eclipse/cdt/core/build/managed/tests/AllBuildTests.java index 78bdf4e4afc..593e1173ed1 100644 --- a/core/org.eclipse.cdt.core.tests/build/org/eclipse/cdt/core/build/managed/tests/AllBuildTests.java +++ b/core/org.eclipse.cdt.core.tests/build/org/eclipse/cdt/core/build/managed/tests/AllBuildTests.java @@ -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(); diff --git a/core/org.eclipse.cdt.core.tests/build/org/eclipse/cdt/core/build/managed/tests/StandardBuildTests.java b/core/org.eclipse.cdt.core.tests/build/org/eclipse/cdt/core/build/managed/tests/StandardBuildTests.java new file mode 100644 index 00000000000..3b929310bad --- /dev/null +++ b/core/org.eclipse.cdt.core.tests/build/org/eclipse/cdt/core/build/managed/tests/StandardBuildTests.java @@ -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 name 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 IProject 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); + } +} diff --git a/core/org.eclipse.cdt.core/ChangeLog b/core/org.eclipse.cdt.core/ChangeLog index 3e7152c0572..cda4b11f18e 100644 --- a/core/org.eclipse.cdt.core/ChangeLog +++ b/core/org.eclipse.cdt.core/ChangeLog @@ -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. diff --git a/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IResourceBuildInfo.java b/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IManagedBuildInfo.java similarity index 98% rename from core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IResourceBuildInfo.java rename to core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IManagedBuildInfo.java index c42170e900d..7684d41f982 100644 --- a/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IResourceBuildInfo.java +++ b/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IManagedBuildInfo.java @@ -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 diff --git a/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/ManagedBuildManager.java b/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/ManagedBuildManager.java index 8d261f0d547..fe6443a2593 100644 --- a/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/ManagedBuildManager.java +++ b/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/ManagedBuildManager.java @@ -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); + } } } diff --git a/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/standard/StandardBuildManager.java b/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/standard/StandardBuildManager.java new file mode 100644 index 00000000000..263e307cbdc --- /dev/null +++ b/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/standard/StandardBuildManager.java @@ -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); + } + } +} diff --git a/core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/ResourceBuildInfo.java b/core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/ManagedBuildInfo.java similarity index 90% rename from core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/ResourceBuildInfo.java rename to core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/ManagedBuildInfo.java index 8cd236cbadc..04502ea575e 100644 --- a/core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/ResourceBuildInfo.java +++ b/core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/ManagedBuildInfo.java @@ -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 diff --git a/core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/Target.java b/core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/Target.java index 406972b5674..b01bf3ba74d 100644 --- a/core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/Target.java +++ b/core/org.eclipse.cdt.core/build/org/eclipse/cdt/internal/core/build/managed/Target.java @@ -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 diff --git a/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IManagedBuildPathInfo.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfo.java similarity index 58% rename from core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IManagedBuildPathInfo.java rename to core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfo.java index 03fbcc20f11..c0170f09d27 100644 --- a/core/org.eclipse.cdt.core/build/org/eclipse/cdt/core/build/managed/IManagedBuildPathInfo.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfo.java @@ -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 String array containing all the defined - * preprocessor symbols. If there are no defined symbols, the receiver - * will return an empty array, never null + * Answers a Map 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 null. + * * @return */ - public String[] getDefinedSymbols(); + public Map getDefinedSymbols(); /** * Answers a String array containing all the known include diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfoChangeListener.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfoChangeListener.java new file mode 100644 index 00000000000..161dc941e4a --- /dev/null +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfoChangeListener.java @@ -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); + +} diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfoProvider.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfoProvider.java new file mode 100644 index 00000000000..db15f417dd2 --- /dev/null +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/IScannerInfoProvider.java @@ -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 + * IResource it is responsible for changes. + * + * @param listener + */ + public void subscribe(IResource resource, IScannerInfoChangeListener listener); + + /** + * Answers true if the receiver has information for + * the resource specified in the argument, else false. + * + * @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); +} diff --git a/core/org.eclipse.cdt.core/plugin.xml b/core/org.eclipse.cdt.core/plugin.xml index 7fcd93752b1..b7f4b930ad2 100644 --- a/core/org.eclipse.cdt.core/plugin.xml +++ b/core/org.eclipse.cdt.core/plugin.xml @@ -33,6 +33,7 @@ + @@ -279,6 +280,19 @@ pattern="*.exe"> + + + + + + diff --git a/core/org.eclipse.cdt.core/schema/ManagedBuildTools.exsd b/core/org.eclipse.cdt.core/schema/ManagedBuildTools.exsd index 022f635c190..5c86003ad6b 100644 --- a/core/org.eclipse.cdt.core/schema/ManagedBuildTools.exsd +++ b/core/org.eclipse.cdt.core/schema/ManagedBuildTools.exsd @@ -393,7 +393,7 @@ Two additional types exist to flag options of special relevance to the build mod - CDT 1.1 + 1.2 diff --git a/core/org.eclipse.cdt.core/schema/ScannerInfoProvider.exsd b/core/org.eclipse.cdt.core/schema/ScannerInfoProvider.exsd new file mode 100644 index 00000000000..9980b0ca2f9 --- /dev/null +++ b/core/org.eclipse.cdt.core/schema/ScannerInfoProvider.exsd @@ -0,0 +1,121 @@ + + + + + + + + + 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. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A unique name that will be used to reference this parser. + + + + + + + A fully qualified name of the Java class that implements <samp>org.eclipse.cdt.core.parser.IScannerProviderInfo</samp> interface + + + + + + + + + + + + + + + 1.2 + + + + + + + + + [Enter extension point usage example here.] + + + + + + + + + The following is an example of the extension point usage: +<p> +<pre> +<extension + id="org.eclipse.cdt.core.ScannerInfoProvider" + name="Scanner Information Provider" + point="org.eclipse.cdt.core.ScannerInfoProvider"> + <provider + id="org.eclipse.cdt.core.provider.managed" + class="org.eclipse.cdt.core.build.managed.ManagedBuildManager"> + </provider> +</extension> +</pre> + + + + + + + + + [Enter information about supplied implementation of this extension point.] + + + + + + + + + + + + + diff --git a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/BuildInfoFactory.java b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/BuildInfoFactory.java index 90ab6163217..76310bd998f 100644 --- a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/BuildInfoFactory.java +++ b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/BuildInfoFactory.java @@ -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 IBuildInfo { + public static abstract class Store implements IStandardBuildInfo, IScannerInfo { + // List of include paths + protected List pathList; + protected List symbolList; + 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 { @@ -169,18 +253,41 @@ 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; + } } diff --git a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/CProjectNature.java b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/CProjectNature.java index c1ab2814e66..99b3c8014df 100644 --- a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/CProjectNature.java +++ b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/CProjectNature.java @@ -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); } + } diff --git a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/resources/IBuildInfo.java b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/resources/IStandardBuildInfo.java similarity index 53% rename from core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/resources/IBuildInfo.java rename to core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/resources/IStandardBuildInfo.java index b05e68b3b6f..80e3aa5309f 100644 --- a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/resources/IBuildInfo.java +++ b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/resources/IStandardBuildInfo.java @@ -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); } diff --git a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/internal/core/GeneratedMakefileBuilder.java b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/internal/core/GeneratedMakefileBuilder.java index 69aef8c99ef..34bbb1811e5 100644 --- a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/internal/core/GeneratedMakefileBuilder.java +++ b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/internal/core/GeneratedMakefileBuilder.java @@ -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); diff --git a/core/org.eclipse.cdt.ui/ChangeLog b/core/org.eclipse.cdt.ui/ChangeLog index 503237c09f1..1117e35442e 100644 --- a/core/org.eclipse.cdt.ui/ChangeLog +++ b/core/org.eclipse.cdt.ui/ChangeLog @@ -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: diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/ui/wizards/BuildPathInfoBlock.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/ui/wizards/BuildPathInfoBlock.java index aa6aecdb1c7..d5d74c7bb84 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/ui/wizards/BuildPathInfoBlock.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/ui/wizards/BuildPathInfoBlock.java @@ -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); - monitor.beginTask("Setting Include Paths", 1); - String paths = getPathListContents(); - nature.setIncludePaths(paths, monitor); - monitor.beginTask("Setting Defined Symbols", 1); - String symbols = getSymbolListContents(); - nature.setDefinedSymbols(symbols, monitor); - - } - catch (CoreException e) { + if (monitor == null) { + monitor = new NullProgressMonitor(); } + if (project != null) { + // Store the paths and symbols + monitor.beginTask("Setting Include Paths", 1); + StandardBuildManager.setIncludePaths(project, getPathListContents()); + monitor.beginTask("Setting Defined Symbols", 1); + StandardBuildManager.setPreprocessorSymbols(project, getSymbolListContents()); + + StandardBuildManager.saveBuildInfo(project); + } } /* @@ -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()); } }