bug 357442: Tidy EnvironmentVariableManagerToolChain

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}

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.CdtVariableManager;
-import org.eclipse.cdt.internal.core.cdtvariables.DefaultVariableContextInfo;
-import org.eclipse.cdt.internal.core.cdtvariables.EnvironmentVariableSupplier;
 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;
 
-	/**
+	public EnvironmentVariableManagerToolChain(IToolChain toolchain) {
-	 * Basically, converter from IEnvironmentVariable to ICdtVariable (build macros) which
+		this.toolChain = toolchain;
-	 * 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;
-		}
 	}
 
-	private final class EnvironmentContextInfoToolChain implements IEnvironmentContextInfo {
+	/**
-		private final IToolChain toolChain;
+	 * Wrapper class to deliver appropriate set of environment variable suppliers.
-
+	 */
-		private EnvironmentContextInfoToolChain(IToolChain toolChain) {
+	private class ToolChainEnvironmentContextInfo implements IEnvironmentContextInfo {
-			this.toolChain = toolChain;
+		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();
+			return new ICoreEnvironmentVariableSupplier[] {
-			
+					fUserSupplier,
-			ICoreEnvironmentVariableSupplier toolchainSupplier = new ICoreEnvironmentVariableSupplier() {
+					fToolchainSupplier,
-				@Override
+					fEclipseSupplier,
-				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 };
 		}
-
 		@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)
+	 * Wrapper class to deliver appropriate set of suppliers for variable substitution.
-			fInstance = new EnvironmentVariableManagerToolChain();
+	 */
-		return fInstance;
+	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 ToolChainEnvironmentContextInfo(toolChain);
-			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);
 	}
 
+	/**
+	 * 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 ToolChainCoreVariableContextInfo(toolChain);
-			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;
 	}
 
 }

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);
 	}
-
 }