Tasking Project to VSCode

A VSCode extension that converts Tasking and HighTec (TriCore) Eclipse project configurations to VSCode settings, making it easier to work with embedded C projects in Visual Studio Code.

Supported Toolchains

The extension reads the Eclipse CDT project file (.cproject) of the folder that is opened as the workspace and selects the matching parser automatically:

• Tasking (C/C++ Compiler tool): predefined macros, include paths, pre-include files and excluded sources.
• HighTec TriCore (TriCore C Compiler tool): macros from Defined symbols (-D), include paths from Include Paths, pre-include files declared in the tool chain Other options (-include "...") and excluded sources from the source entries.

Both parsers convert the Eclipse path variables (${workspace_loc:/${ProjName}/...} and ${ProjDirPath}/...) into paths relative to the project root.

If the workspace contains no .cproject file at all, a generic configuration is derived from the project layout instead, see Plain C Projects.

Features

• Automatically detects and converts Tasking and HighTec project configurations (.cproject files)
• Falls back to a generic configuration for plain C projects that have no .cproject file
• Extracts and converts:
  • Predefined macros
  • Include paths
  • Excluding paths
  • Forced include files
• Supports multiple configurations with configuration selector
• Generates VSCode configuration files:
  • settings.json for file exclusion rules, clangd arguments and diagnostics
  • compile_commands.json for clangd integration
  • .clangd for clangd compile flags and diagnostic suppression
• Enhanced clangd support with optimized settings for better code intelligence

Requirements

• Visual Studio Code version 1.80.0 or higher
• clangd extension for VSCode (required, it is the only consumer of the generated configuration)

Installation

1. Download the extension package
2. Install it in VSCode using the Extensions view
3. Reload VSCode

Usage

1. Open your Tasking, HighTec or plain C project folder in VSCode
2. Press Ctrl+Shift+P (Windows/Linux) or Cmd+Shift+P (macOS) to open the Command Palette
3. Type "Convert Tasking Project" and select the command
4. Choose the configuration you want to convert when prompted
5. The extension will create/update the necessary VSCode configuration files

Plain C Projects (without a .cproject file)

Plain C projects are just a folder full of sources, there is no project file to read include paths or macros from. When no .cproject file is found, the extension derives a configuration from the project layout, so clangd still resolves includes and navigates code:

• Include paths are collected from the project root and from every directory that contains a header file (.h, .hpp, .hh, .hxx), shallowest directory first. Quoted includes already resolve against the directory of the including file, so the derived -I paths are what make angle bracket includes work.
• Macros are empty by default, because there is nothing to read them from. Add the ones your project needs to tasking-to-vscode.fallbackDefines.
• Hidden directories (.git, .vscode, ...) are never indexed. Other directories, for example a vendored node_modules, are indexed, the extension does not guess which directories hold build output.
• An existing compile_commands.json in the project root belongs to a real build system (CMake, Make, ...). It is more accurate than anything that can be derived here and clangd finds it on its own, so it is never overwritten.
• An existing .clangd file is never overwritten unless it was written by this extension. Generated files start with a marker comment on their first line.

Turn the fallback off with tasking-to-vscode.fallbackToGenericCProject if you only ever want configurations coming from a real .cproject file.

Extension Settings

This extension contributes the following settings:

• tasking-to-vscode.enableCompileCommands: Enable generation of compile_commands.json file for clangd integration. When enabled, the extension will generate a compile_commands.json file based on your Tasking project configuration, providing enhanced code intelligence features through clangd. Default is true.
• tasking-to-vscode.clangdDiagnosticsSuppressOptions: Configure the Diagnostics.Suppress options in the .clangd file to suppress specific diagnostic warnings. Multiple values can be specified as an array. Default is ["attributes_not_allowed"].
• tasking-to-vscode.cStandard: C language standard passed to clangd as -std=<value> for every translation unit. Leave it empty to let clangd use its own default. Default is "gnu99".
• tasking-to-vscode.fallbackToGenericCProject: Generate a generic clangd configuration when the workspace contains no Eclipse .cproject file. Default is true.
• tasking-to-vscode.fallbackDefines: Preprocessor macros used by the generic fallback configuration, e.g. ["DEBUG=1"]. There is no project file to read them from, so the list is empty by default.

Clangd Integration

The extension generates a compile_commands.json file in the .vscode directory, which enables advanced code intelligence features through clangd:

• Accurate code completion and diagnostics
• Smart header file inclusion
• Cross-file symbol renaming
• Background indexing for better performance
• Detailed completion suggestions

c_cpp_properties.json is not written anymore, it is only consumed by the Microsoft C/C++ extension and clangd ignores it. If an older version of this extension created one, it is left untouched; delete it manually if you do not use the C/C++ extension.

After writing the configuration the extension activates the clangd extension if it is not running yet and restarts the language server, so the new compilation database and .clangd are picked up by the current session instead of the next one. If the restart is not possible (clangd is not installed, for example) the success message says so and you can run clangd: Restart language server manually.

Known Issues

• Path conversion limitations: Some complex path configurations in the Tasking project may not be correctly converted to VSCode format
• Performance considerations: Projects with extremely large numbers of exclude paths (>100) may experience slower initial configuration generation

Troubleshooting

spawn ENAMETOOLONG Error in Projects with Many Exclude Paths

If you encounter a spawn ENAMETOOLONG error when using the extension, this is typically caused by:

• Too many exclude paths in your .cproject file (the main cause)
• Each exclude path being converted to complex glob patterns
• The combined exclude pattern string exceeding system command line argument limits

Root Cause: When your Tasking project has dozens or hundreds of exclude paths in the .cproject file, the extension converts each path to a glob pattern and combines them into a single string for vscode.workspace.findFiles. This can result in command line arguments that exceed system limits (typically around 8000 characters).

Solution: The extension automatically handles this in version 1.0.9 and later by:

• Limiting the maximum number of exclude patterns to 50
• Limiting the total exclude string length to 8000 characters
• Using a fallback strategy when limits are exceeded:
  • Priority given to hidden directory exclusions (.git, .vscode, etc.)
  • Important exclude patterns are preserved up to the length limit
  • Warning messages are logged when patterns are limited

Manual Workarounds (if needed):

1. Reduce the number of exclude paths in your .cproject file
2. Combine similar exclude patterns where possible
3. Check the VSCode output console for warning messages about pattern limiting

Release Notes

1.0.12

• Removed the c_cpp_properties.json generation, it is only consumed by the Microsoft C/C++ extension and clangd ignores it. clangd gets everything it needs from compile_commands.json and .clangd
• The C_Cpp.exclusionPolicy entry is no longer written to .vscode/settings.json, files.exclude is kept because it is a core VSCode (explorer) setting
• The cStandard setting only feeds -std= in the compilation database now

1.0.11

• Removed GNU Global support, code navigation is done by clangd only
• Fixed clangd not being restarted after the conversion when the clangd extension had not been activated yet, which made a second run of the command necessary
• The clangd restart now waits until the newly written clangd.arguments are visible, instead of restarting with the previous arguments
• Added a fallback for plain C projects without a .cproject file: include paths are derived from the project layout and clangd is configured from that
• Added tasking-to-vscode.fallbackToGenericCProject, tasking-to-vscode.fallbackDefines and tasking-to-vscode.cStandard settings
• An existing compile_commands.json in the project root (CMake, Make, ...) is no longer overwritten
• A hand written .clangd file is no longer overwritten, generated ones carry a marker comment
• clangd.arguments in settings.json keeps user defined arguments instead of replacing them

1.0.10

• Added support for HighTec TriCore projects
• Added tool chain detection so Tasking and HighTec .cproject files are parsed with the matching parser
• HighTec pre-include files are read from the tool chain Other options list
• Forced include files are emitted as separate compiler arguments

1.0.9

• Fixed critical spawn ENAMETOOLONG error caused by too many exclude paths in .cproject files
• Added intelligent exclude pattern limiting (max 50 patterns, max 8000 characters)
• Implemented fallback strategy to preserve most important exclude patterns when limits are exceeded
• Enhanced error handling with detailed warning messages for pattern limitation
• Improved performance for projects with large numbers of exclude configurations

1.0.8

• Fixed spawn ENAMETOOLONG error in Git-managed projects by automatically excluding hidden directories (starting with .) from file searches
• Improved performance in projects with large numbers of files by filtering out .git, .vscode, and other hidden directories
• Enhanced file search efficiency and reduced memory usage during configuration generation

1.0.7

• Optimized user experience for single configuration scenarios: Automatically use the configuration without displaying the selection dialog when the project has only one configuration

1.0.6

• Added clangdDiagnosticsSuppressOptions configuration for customizing clangd diagnostic warnings
• Enhanced clangd integration with configurable warning suppression

1.0.5

• restart clangd server after configuration changes

1.0.4

• Add arguments -ferror-limit=0 for clangd

1.0.3

• Add arguments for clangd

1.0.2

• Added support for Tasking compiler-specific identifiers
• Improved macro handling and compiler compatibility
• Enhanced configuration parsing for better Tasking integration

1.0.1

• Added compile_commands.json generation for clangd integration
• Enhanced clangd configuration with optimized settings
• Added support for forced include files
• Improved path processing for better compatibility
• Enhanced exclude path handling for both files and directories

1.0.0

Initial release of Tasking Project to VSCode converter with the following features:

• Basic Tasking project configuration conversion
• Multiple configuration support