Dynamic ESP-IDF Target Discovery and Support Preview Targets

bundles/com.espressif.idf.core/plugin.xml

@@ -244,72 +244,6 @@ config-only component and an interface library is created instead."
            name="KCONFIG_PROJBUILD">
      </property>
   </extension>
-  <extension point="com.espressif.idf.core.toolchain">
-     <ToolChain
-           arch="xtensa"
-           compilerPattern="(?:xtensa-esp-elf|xtensa-esp32-elf)[\\/]+bin[\\/]+xtensa-esp32-elf-gcc(?:\.exe)?$"
-           debuggerPattern="xtensa-esp32-elf-gdb(\.exe)?$"
-           fileName="toolchain-esp32.cmake"
-           id="xtensa-esp32-elf"
-           name="esp32">
-     </ToolChain>
-     <ToolChain
-           arch="xtensa"
-           compilerPattern="(?:xtensa-esp-elf|xtensa-esp32s2-elf)[\\/]+bin[\\/]+xtensa-esp32s2-elf-gcc(?:\.exe)?$"
-           debuggerPattern="xtensa-esp32s2-elf-gdb(\.exe)?$"
-           fileName="toolchain-esp32s2.cmake"
-           id="xtensa-esp32s2-elf"
-           name="esp32s2">
-     </ToolChain>
-     <ToolChain
-           arch="xtensa"
-           compilerPattern="(?:xtensa-esp-elf|xtensa-esp32s3-elf)[\\/]+bin[\\/]+xtensa-esp32s3-elf-gcc(?:\.exe)?$"
-           debuggerPattern="xtensa-esp32s3-elf-gdb(\.exe)?$"
-           fileName="toolchain-esp32s3.cmake"
-           id="xtensa-esp32s3-elf"
-           name="esp32s3">
-     </ToolChain>
-     <ToolChain
-           arch="riscv32"
-           compilerPattern="riscv32-esp-elf[\\/]+bin[\\/]+riscv32-esp-elf-gcc(?:\.exe)?$"
-           debuggerPattern="riscv32-esp-elf-gdb(\.exe)?$"
-           fileName="toolchain-esp32c2.cmake"
-           id="riscv32-esp-elf"
-           name="esp32c2">
-     </ToolChain>
-     <ToolChain
-           arch="riscv32"
-           compilerPattern="riscv32-esp-elf[\\/]+bin[\\/]+riscv32-esp-elf-gcc(?:\.exe)?$"
-           debuggerPattern="riscv32-esp-elf-gdb(\.exe)?$"
-           fileName="toolchain-esp32c3.cmake"
-           id="riscv32-esp-elf"
-           name="esp32c3">
-     </ToolChain>
-     <ToolChain
-           arch="riscv32"
-           compilerPattern="riscv32-esp-elf[\\/]+bin[\\/]+riscv32-esp-elf-gcc(?:\.exe)?$"
-           debuggerPattern="riscv32-esp-elf-gdb(\.exe)?$"
-           fileName="toolchain-esp32c6.cmake"
-           id="riscv32-esp-elf"
-           name="esp32c6">
-     </ToolChain>
-          <ToolChain
-           arch="riscv32"
-           compilerPattern="riscv32-esp-elf[\\/]+bin[\\/]+riscv32-esp-elf-gcc(?:\.exe)?$"
-           debuggerPattern="riscv32-esp-elf-gdb(\.exe)?$"
-           fileName="toolchain-esp32h2.cmake"
-           id="riscv32-esp-elf"
-           name="esp32h2">
-     </ToolChain>
-          <ToolChain
-                arch="riscv32"
-                compilerPattern="riscv32-esp-elf[\\/]+bin[\\/]+riscv32-esp-elf-gcc(?:\.exe)?$"
-                debuggerPattern="riscv32-esp-elf-gdb(\.exe)?$"
-                fileName="toolchain-esp32p4.cmake"
-                id="riscv32-esp-elf"
-                name="esp32p4">
-          </ToolChain>
-  </extension>
   <extension point="org.eclipse.core.variables.dynamicVariables">
      <variable
            description="%openocd_bin_path"

bundles/com.espressif.idf.core/src/com/espressif/idf/core/DefaultBoardProvider.java

@@ -58,6 +58,12 @@ public String getDefaultBoard(String targetName)
 	{
 		List<Board> boardsList = this.espConfigParser.getBoardsForTarget(targetName);
 		String[] boards = boardsList.stream().map(Board::name).toArray(String[]::new);
+
+		if (boards.length == 0)
+		{
+			return EspTarget.enumOf(targetName).board;
+		}
+
 		return boards[getIndexOfDefaultBoard(targetName, boards)];
 	}
 

bundles/com.espressif.idf.core/src/com/espressif/idf/core/toolchain/ESPToolChainManager.java

@@ -34,10 +34,8 @@
 import org.eclipse.cdt.core.build.IToolChainManager;
 import org.eclipse.cdt.core.build.IToolChainProvider;
 import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IConfigurationElement;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Platform;
 import org.eclipse.launchbar.core.target.ILaunchTarget;
 import org.eclipse.launchbar.core.target.ILaunchTargetManager;
 import org.eclipse.launchbar.core.target.ILaunchTargetWorkingCopy;
@@ -74,23 +72,27 @@ public ESPToolChainManager()
 
 	private static Map<String, ESPToolChainElement> readESPToolchainRegistry()
 	{
-		IConfigurationElement[] configElements = Platform.getExtensionRegistry()
-				.getConfigurationElementsFor("com.espressif.idf.core.toolchain"); //$NON-NLS-1$
-		for (IConfigurationElement iConfigurationElement : configElements)
+		// Read targets dynamically from ESP-IDF constants.py instead of plugin.xml
+		String idfPath = IDFUtil.getIDFPath();
+		IDFTargets idfTargets = IDFTargetsReader.readTargetsFromEspIdf(idfPath);
+
+		// Convert dynamic targets to toolchain elements
+		for (IDFTargets.IDFTarget target : idfTargets.getAllTargets())
 		{
-			String name = iConfigurationElement.getAttribute("name"); //$NON-NLS-1$
-			String id = iConfigurationElement.getAttribute("id"); //$NON-NLS-1$
-			String arch = iConfigurationElement.getAttribute("arch"); //$NON-NLS-1$
-			String fileName = iConfigurationElement.getAttribute("fileName"); //$NON-NLS-1$
-			String compilerPattern = iConfigurationElement.getAttribute("compilerPattern"); //$NON-NLS-1$
-			String debuggerPatten = iConfigurationElement.getAttribute("debuggerPattern"); //$NON-NLS-1$
+			String name = target.getName();
+			String id = target.getToolchainId();
+			String arch = target.getArchitecture();
+			String fileName = target.getToolchainFileName();
+			String compilerPattern = target.getCompilerPattern();
+			String debuggerPattern = target.getDebuggerPattern();
 
 			String uniqueToolChainId = name.concat("/").concat(arch).concat("/").concat(fileName); //$NON-NLS-1$ //$NON-NLS-2$
 
 			toolchainElements.put(uniqueToolChainId,
-					new ESPToolChainElement(name, id, arch, fileName, compilerPattern, debuggerPatten));
-
+					new ESPToolChainElement(name, id, arch, fileName, compilerPattern, debuggerPattern));
 		}
+
+		Logger.log("Dynamically loaded " + toolchainElements.size() + " toolchain elements from ESP-IDF"); //$NON-NLS-1$ //$NON-NLS-2$
 		return toolchainElements;
 	}
 

bundles/com.espressif.idf.core/src/com/espressif/idf/core/toolchain/IDFTargets.java

@@ -0,0 +1,143 @@
+/*******************************************************************************
+ * Copyright 2025 Espressif Systems (Shanghai) PTE LTD. All rights reserved.
+ * Use is subject to license terms.
+ *******************************************************************************/
+
+package com.espressif.idf.core.toolchain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import com.espressif.idf.core.toolchain.enums.Target;
+
+/**
+ * Class to hold ESP-IDF target information including preview status
+ * 
+ * @author Kondal Kolipaka <[email protected]>, Ali Azam Rana <[email protected]>
+ *
+ */
+public class IDFTargets
+{
+	private List<IDFTarget> supportedTargets;
+	private List<IDFTarget> previewTargets;
+
+	public IDFTargets()
+	{
+		this.supportedTargets = new ArrayList<>();
+		this.previewTargets = new ArrayList<>();
+	}
+
+	public void addSupportedTarget(String targetName)
+	{
+		Target t = Target.fromString(targetName);
+		if (t != null)
+			supportedTargets.add(new IDFTarget(t, false));
+	}
+
+	public void addPreviewTarget(String targetName)
+	{
+		Target t = Target.fromString(targetName);
+		if (t != null)
+			previewTargets.add(new IDFTarget(t, true));
+	}
+
+	public List<IDFTarget> getAllTargets()
+	{
+		List<IDFTarget> all = new ArrayList<>(supportedTargets);
+		all.addAll(previewTargets);
+		return all;
+	}
+
+	public List<IDFTarget> getSupportedTargets()
+	{
+		return supportedTargets;
+	}
+
+	public List<IDFTarget> getPreviewTargets()
+	{
+		return previewTargets;
+	}
+
+	public boolean hasTarget(String targetName)
+	{
+		Target t = Target.fromString(targetName);
+		return t != null && getAllTargets().stream().anyMatch(x -> x.getTarget() == t);
+	}
+
+	public IDFTarget getTarget(String targetName)
+	{
+		Target t = Target.fromString(targetName);
+		return t == null ? null : getAllTargets().stream().filter(x -> x.getTarget() == t).findFirst().orElse(null);
+	}
+
+	public List<String> getAllTargetNames()
+	{
+		return getAllTargets().stream().map(IDFTarget::getName).collect(Collectors.toList());
+	}
+
+	public List<String> getSupportedTargetNames()
+	{
+		return getSupportedTargets().stream().map(IDFTarget::getName).collect(Collectors.toList());
+	}
+
+	public List<String> getPreviewTargetNames()
+	{
+		return getPreviewTargets().stream().map(IDFTarget::getName).collect(Collectors.toList());
+	}
+
+	/**
+	 * Inner class representing a single IDF target
+	 */
+	public static class IDFTarget
+	{
+		private final Target target;
+		private final boolean isPreview;
+
+		public IDFTarget(Target target, boolean isPreview)
+		{
+			this.target = target;
+			this.isPreview = isPreview;
+		}
+
+		public String getName()
+		{
+			return target.idfName();
+		}
+
+		public boolean isPreview()
+		{
+			return isPreview;
+		}
+
+		public Target getTarget()
+		{
+			return target;
+		}
+
+		public String getArchitecture()
+		{
+			return target.architectureId();
+		}
+
+		public String getToolchainId()
+		{
+			return target.toolchainId();
+		}
+
+		public String getCompilerPattern()
+		{
+			return target.compilerPattern();
+		}
+
+		public String getDebuggerPattern()
+		{
+			return target.debuggerPattern();
+		}
+
+		public String getToolchainFileName()
+		{
+			return target.toolchainFileName();
+		}
+	}
+}