From 180b19205413a0d73baf1a19adf98c816b38d3fb Mon Sep 17 00:00:00 2001 From: Andrew Gvozdev Date: Sun, 10 Mar 2013 07:21:32 -0400 Subject: [PATCH] bug 357442: Tidy EnvironmentVariableManagerToolChain --- .../DataProviderMessages.properties | 2 +- .../EnvironmentVariableManagerToolChain.java | 280 +++++++----------- .../cygwin/IsGnuCygwinToolChainSupported.java | 19 +- 3 files changed, 132 insertions(+), 169 deletions(-) diff --git a/build/org.eclipse.cdt.managedbuilder.core/src/org/eclipse/cdt/managedbuilder/internal/dataprovider/DataProviderMessages.properties b/build/org.eclipse.cdt.managedbuilder.core/src/org/eclipse/cdt/managedbuilder/internal/dataprovider/DataProviderMessages.properties index 1127a644861..87a33f0753c 100644 --- a/build/org.eclipse.cdt.managedbuilder.core/src/org/eclipse/cdt/managedbuilder/internal/dataprovider/DataProviderMessages.properties +++ b/build/org.eclipse.cdt.managedbuilder.core/src/org/eclipse/cdt/managedbuilder/internal/dataprovider/DataProviderMessages.properties @@ -21,5 +21,5 @@ ProjectConverter.6=the project conversion failed ProjectConverter.7=targets conversion ProjectConverter.8=the project conversion failed due to unknown reason ProjectConverter.9=the given project is not a valid CDT project -BuildConfigurationData.NoToolchainSupport=Toolchain "{0}" is not detected. Refer to "C/C++ Development User Guide", "Before you begin" about installing toolchains. +BuildConfigurationData.NoToolchainSupport=Toolchain "{0}" is not detected. Refer to "C/C++ Development User Guide", "Before you begin" how to install toolchains. BuildConfigurationData.OrphanedConfiguration=Orphaned configuration. No base extension cfg exists for {0} diff --git a/build/org.eclipse.cdt.managedbuilder.core/src/org/eclipse/cdt/managedbuilder/internal/envvar/EnvironmentVariableManagerToolChain.java b/build/org.eclipse.cdt.managedbuilder.core/src/org/eclipse/cdt/managedbuilder/internal/envvar/EnvironmentVariableManagerToolChain.java index 5072fc95c50..451b6918fbb 100644 --- a/build/org.eclipse.cdt.managedbuilder.core/src/org/eclipse/cdt/managedbuilder/internal/envvar/EnvironmentVariableManagerToolChain.java +++ b/build/org.eclipse.cdt.managedbuilder.core/src/org/eclipse/cdt/managedbuilder/internal/envvar/EnvironmentVariableManagerToolChain.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2012, 2012 Andrew Gvozdev and others. + * Copyright (c) 2012, 2013 Andrew Gvozdev and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at @@ -12,16 +12,11 @@ package org.eclipse.cdt.managedbuilder.internal.envvar; import org.eclipse.cdt.core.cdtvariables.ICdtVariable; import org.eclipse.cdt.core.envvar.IEnvironmentVariable; -import org.eclipse.cdt.core.settings.model.ICConfigurationDescription; -import org.eclipse.cdt.internal.core.cdtvariables.DefaultVariableContextInfo; -import org.eclipse.cdt.internal.core.cdtvariables.EnvironmentVariableSupplier; +import org.eclipse.cdt.internal.core.cdtvariables.CdtVariableManager; import org.eclipse.cdt.internal.core.cdtvariables.ICoreVariableContextInfo; -import org.eclipse.cdt.internal.core.envvar.DefaultEnvironmentContextInfo; -import org.eclipse.cdt.internal.core.envvar.EnvVarDescriptor; import org.eclipse.cdt.internal.core.envvar.EnvironmentVariableManager; import org.eclipse.cdt.internal.core.envvar.ICoreEnvironmentVariableSupplier; import org.eclipse.cdt.internal.core.envvar.IEnvironmentContextInfo; -import org.eclipse.cdt.managedbuilder.core.IConfiguration; import org.eclipse.cdt.managedbuilder.core.IToolChain; import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; import org.eclipse.cdt.managedbuilder.envvar.IConfigurationEnvironmentVariableSupplier; @@ -29,192 +24,145 @@ import org.eclipse.cdt.managedbuilder.envvar.IEnvironmentVariableProvider; import org.eclipse.cdt.utils.cdtvariables.ICdtVariableSupplier; import org.eclipse.cdt.utils.cdtvariables.IVariableContextInfo; - /** * Helper class to resolve environment variables directly from toolchain. The intention is - * to use that in New Project Wizard scenarios when no configuration is available yet. + * to use that in New Project Wizard and other scenarios when no configuration is available yet. + * + * @noextend This class is not intended to be subclassed by clients. */ public class EnvironmentVariableManagerToolChain extends EnvironmentVariableManager { - private static EnvironmentVariableManagerToolChain fInstance = null; + private final IToolChain toolChain; - /** - * Basically, converter from IEnvironmentVariable to ICdtVariable (build macros) which - * is used by EnvironmentVariableManager implementation to resolve variables/macros. - */ - private final class CoreVariableContextInfoToolChain implements ICoreVariableContextInfo { - public final static int CONTEXT_TOOLCHAIN = 1009; // arbitrary value different from ICoreVariableContextInfo.CONTEXT_XXX - - private final IToolChain toolChain; - private final IConfigurationEnvironmentVariableSupplier mbsSupplier; - - private CoreVariableContextInfoToolChain(IToolChain toolChain) { - this.toolChain = toolChain; - this.mbsSupplier = toolChain.getEnvironmentVariableSupplier(); - } - - @Override - public ICdtVariableSupplier[] getSuppliers() { - ICdtVariableSupplier sup = new ICdtVariableSupplier() { - @Override - public ICdtVariable getVariable(String macroName, IVariableContextInfo context) { - IEnvironmentVariable var = mbsSupplier.getVariable(macroName, null, ManagedBuildManager.getEnvironmentVariableProvider()); - return EnvironmentVariableSupplier.getInstance().createBuildMacro(var); - } - @Override - public ICdtVariable[] getVariables(IVariableContextInfo context) { - IEnvironmentVariable[] vars = mbsSupplier.getVariables(null, ManagedBuildManager.getEnvironmentVariableProvider()); - if (vars != null) { - ICdtVariable[] cdtVars = new ICdtVariable[vars.length]; - for (int i = 0; i < vars.length; i++) { - cdtVars[i] = EnvironmentVariableSupplier.getInstance().createBuildMacro(vars[i]); - } - } - return null; - } - - }; - return new ICdtVariableSupplier[] { sup }; - } - - @Override - public IVariableContextInfo getNext() { - return new DefaultVariableContextInfo(ICoreVariableContextInfo.CONTEXT_WORKSPACE, null); - } - - @Override - public int getContextType() { - return CONTEXT_TOOLCHAIN; - } - - @Override - public Object getContextData() { - return toolChain; - } + public EnvironmentVariableManagerToolChain(IToolChain toolchain) { + this.toolChain = toolchain; } - private final class EnvironmentContextInfoToolChain implements IEnvironmentContextInfo { - private final IToolChain toolChain; - - private EnvironmentContextInfoToolChain(IToolChain toolChain) { - this.toolChain = toolChain; + /** + * Wrapper class to deliver appropriate set of environment variable suppliers. + */ + private class ToolChainEnvironmentContextInfo implements IEnvironmentContextInfo { + private final ICoreEnvironmentVariableSupplier fToolchainSupplier; + private ToolChainEnvironmentContextInfo(IToolChain toolChain) { + fToolchainSupplier = new ToolChainEnvironmentVariableSupplier(toolChain); } - @Override public IEnvironmentContextInfo getNext() { - return new DefaultEnvironmentContextInfo(null); + return null; } - @Override public ICoreEnvironmentVariableSupplier[] getSuppliers() { - final IConfigurationEnvironmentVariableSupplier cevSupplier = toolChain.getEnvironmentVariableSupplier(); - - ICoreEnvironmentVariableSupplier toolchainSupplier = new ICoreEnvironmentVariableSupplier() { - @Override - public IEnvironmentVariable getVariable(String name, Object context) { - IEnvironmentVariableProvider provider = ManagedBuildManager.getEnvironmentVariableProvider(); - return cevSupplier.getVariable(name, null, provider); - } - @Override - public IEnvironmentVariable[] getVariables(Object context) { - return cevSupplier.getVariables(null, ManagedBuildManager.getEnvironmentVariableProvider()); - } - @Override - public boolean appendEnvironment(Object context) { - // Arbitrary value, it did not appear being used in tested scenarios - return false; - } - }; - return new ICoreEnvironmentVariableSupplier[] { EnvironmentVariableManagerToolChain.fUserSupplier, toolchainSupplier }; + return new ICoreEnvironmentVariableSupplier[] { + fUserSupplier, + fToolchainSupplier, + fEclipseSupplier, + }; } - @Override public Object getContext() { - return toolChain; + return null; + } + } + /** + * Tool-chain variable supplier + */ + private class ToolChainEnvironmentVariableSupplier implements ICoreEnvironmentVariableSupplier { + private final IEnvironmentVariableProvider environmentVariableProvider = EnvironmentVariableProvider.getDefault(); + private final IConfigurationEnvironmentVariableSupplier toolchainSupplier; + + private ToolChainEnvironmentVariableSupplier(IToolChain toolChain) { + this.toolchainSupplier = toolChain.getEnvironmentVariableSupplier(); + } + @Override + public IEnvironmentVariable getVariable(String name, Object context) { + if (toolchainSupplier == null) { + return null; + } + return toolchainSupplier.getVariable(name, null, environmentVariableProvider); + } + @Override + public IEnvironmentVariable[] getVariables(Object context) { + if (toolchainSupplier == null) { + return new IEnvironmentVariable[0]; + } + return toolchainSupplier.getVariables(null, environmentVariableProvider); + } + @Override + public boolean appendEnvironment(Object context) { + return true; } } - public static EnvironmentVariableManagerToolChain getDefault() { - if (fInstance == null) - fInstance = new EnvironmentVariableManagerToolChain(); - return fInstance; + /** + * Wrapper class to deliver appropriate set of suppliers for variable substitution. + */ + private final class ToolChainCoreVariableContextInfo implements ICoreVariableContextInfo { + private final ToolChainCdtVariableSupplier fToolChainSupplier; + private ToolChainCoreVariableContextInfo(IToolChain toolChain) { + fToolChainSupplier = new ToolChainCdtVariableSupplier(toolChain); + } + @Override + public ICdtVariableSupplier[] getSuppliers() { + return new ICdtVariableSupplier[] { + CdtVariableManager.fUserDefinedMacroSupplier, + fToolChainSupplier, + CdtVariableManager.fEnvironmentMacroSupplier, + CdtVariableManager.fCdtMacroSupplier, + CdtVariableManager.fEclipseVariablesMacroSupplier, + }; + } + @Override + public IVariableContextInfo getNext() { + return null; + } + @Override + public int getContextType() { + return CONTEXT_WORKSPACE; + } + @Override + public Object getContextData() { + return null; + } + } + /** + * Tool-chain supplier for variable substitution. + */ + private class ToolChainCdtVariableSupplier implements ICdtVariableSupplier { + private final IConfigurationEnvironmentVariableSupplier toolchainSupplier; + private ToolChainCdtVariableSupplier(IToolChain toolChain) { + this.toolchainSupplier = toolChain.getEnvironmentVariableSupplier(); + } + @Override + public ICdtVariable getVariable(String macroName, IVariableContextInfo context) { + IEnvironmentVariable var = toolchainSupplier.getVariable(macroName, null, ManagedBuildManager.getEnvironmentVariableProvider()); + return CdtVariableManager.fEnvironmentMacroSupplier.createBuildMacro(var); + } + @Override + public ICdtVariable[] getVariables(IVariableContextInfo context) { + IEnvironmentVariable[] vars = toolchainSupplier.getVariables(null, ManagedBuildManager.getEnvironmentVariableProvider()); + if (vars != null) { + ICdtVariable[] cdtVars = new ICdtVariable[vars.length]; + for (int i = 0; i < vars.length; i++) { + cdtVars[i] = CdtVariableManager.fEnvironmentMacroSupplier.createBuildMacro(vars[i]); + } + } + return null; + } } + /** + * Returns context info object which defines environment variable suppliers including tool-chain supplier. + */ @Override public IEnvironmentContextInfo getContextInfo(Object level) { - if (level instanceof IToolChain) { - return new EnvironmentContextInfoToolChain((IToolChain) level); - } - - return super.getContextInfo(level); - } - - @Override - protected int getMacroContextTypeFromContext(Object context) { - if (context instanceof IToolChain) { - return CoreVariableContextInfoToolChain.CONTEXT_TOOLCHAIN; - } - - return super.getMacroContextTypeFromContext(context); + return new ToolChainEnvironmentContextInfo(toolChain); } + /** + * Returns context info object which defines environment variable substitutions including that of tool-chain. + */ @Override public ICoreVariableContextInfo getMacroContextInfoForContext(Object context) { - if (context instanceof IToolChain) { - return new CoreVariableContextInfoToolChain((IToolChain) context); - } - - return super.getMacroContextInfoForContext(context); - } - - /** - * Get environment variable value from toolchain definition. - * - * @param name - name of the variable. - * @param toolChain - toolchain. - * @param resolveMacros - {@code true} to expand macros, {@code false} otherwise. - * - * @return value of the variable. - */ - public IEnvironmentVariable getVariable(String name, IToolChain toolChain, boolean resolveMacros) { - if (name == null || name.isEmpty()) - return null; - - IEnvironmentContextInfo info = getContextInfo(toolChain); - EnvVarDescriptor var = EnvironmentVariableManagerToolChain.getVariable(name,info,true); - - if (var != null && var.getOperation() != IEnvironmentVariable.ENVVAR_REMOVE) { - return resolveMacros ? calculateResolvedVariable(var,info) : var; - } - return null; - } - - /** - * Get environment variable value resolved in context of configuration. - * If no configuration available use toolchain definition. - * - * @param name - name of the variable. - * @param toolChain - toolchain. - * @param resolveMacros - {@code true} to expand macros, {@code false} otherwise. - * - * @return value of the variable. - */ - public String getVariableInConfigurationContext(String name, IToolChain toolChain, boolean resolveMacros) { - if (toolChain == null) { - return null; - } - - IConfiguration cfg = toolChain.getParent(); - ICConfigurationDescription cfgDescription = cfg != null ? ManagedBuildManager.getDescriptionForConfiguration(cfg) : null; - - IEnvironmentVariable var = null; - if (cfgDescription != null) { - var = getVariable(name, cfgDescription, resolveMacros); - } else { - var = getVariable(name, toolChain, resolveMacros); - } - - String value = var != null ? var.getValue() : null; - return value; + return new ToolChainCoreVariableContextInfo(toolChain); } } diff --git a/build/org.eclipse.cdt.managedbuilder.gnu.ui/src/org/eclipse/cdt/managedbuilder/gnu/cygwin/IsGnuCygwinToolChainSupported.java b/build/org.eclipse.cdt.managedbuilder.gnu.ui/src/org/eclipse/cdt/managedbuilder/gnu/cygwin/IsGnuCygwinToolChainSupported.java index 9a2fd648827..21998a342dc 100644 --- a/build/org.eclipse.cdt.managedbuilder.gnu.ui/src/org/eclipse/cdt/managedbuilder/gnu/cygwin/IsGnuCygwinToolChainSupported.java +++ b/build/org.eclipse.cdt.managedbuilder.gnu.ui/src/org/eclipse/cdt/managedbuilder/gnu/cygwin/IsGnuCygwinToolChainSupported.java @@ -11,9 +11,15 @@ *******************************************************************************/ package org.eclipse.cdt.managedbuilder.gnu.cygwin; +import org.eclipse.cdt.core.envvar.IEnvironmentVariable; +import org.eclipse.cdt.core.envvar.IEnvironmentVariableManager; +import org.eclipse.cdt.core.settings.model.ICConfigurationDescription; import org.eclipse.cdt.internal.core.Cygwin; +import org.eclipse.cdt.internal.core.envvar.EnvironmentVariableManager; +import org.eclipse.cdt.managedbuilder.core.IConfiguration; import org.eclipse.cdt.managedbuilder.core.IManagedIsToolChainSupported; import org.eclipse.cdt.managedbuilder.core.IToolChain; +import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; import org.eclipse.cdt.managedbuilder.internal.envvar.EnvironmentVariableManagerToolChain; import org.osgi.framework.Version; @@ -27,8 +33,17 @@ public class IsGnuCygwinToolChainSupported implements IManagedIsToolChainSupport @Override public boolean isSupported(IToolChain toolChain, Version version, String instance) { - String envPath = EnvironmentVariableManagerToolChain.getDefault().getVariableInConfigurationContext(ENV_PATH, toolChain, true); + IConfiguration cfg = toolChain.getParent(); + ICConfigurationDescription cfgDescription = cfg != null ? ManagedBuildManager.getDescriptionForConfiguration(cfg) : null; + + IEnvironmentVariableManager envMngr; + if (cfgDescription != null) { + envMngr = EnvironmentVariableManager.getDefault(); + } else { + envMngr = new EnvironmentVariableManagerToolChain(toolChain); + } + IEnvironmentVariable var = envMngr.getVariable(ENV_PATH, cfgDescription, true); + String envPath = var != null ? var.getValue() : null; return Cygwin.isAvailable(envPath); } - }