Build two different CMake configs in a clean and predicatable way?

[jnz86]

Inside of c_cpp_properties.json, I have application and bootloader configs. This gives me intellesense configurations for each. I have one build kit for ARM GCC. Using CMake and Ninja when not using CMakeTools, but strongly prefer the latter.

All I want to do is build for APPLICATION or BOOTLOADER based on a selection inside VS Code somewhere obvious. I can -D define something for CMakeLists.txt to build each config correctly. But I don't know how to get to that point.

• Making a config in c_cpp_properties seems like it's backwards, it seems CMakeTools should send data to that not get from it.
• Making a new kit doesn't seem right.
• Putting an option in settings.json also seems slightly wrong
• I tried using tasks.json instead of "internal", creating another option called build bootloader and I can get the -D variable into the file, but lose the nice colorized output panel.
• I suppose I could make a header file that had the build type which is included and passed down, but this creates a git issue of files changing every time I want to build a config.

I just some direction in what was intended by the developers.

EDIT: Is any better to have variants that preface with BOOTLOADER or APPLICATION? Debug: Application Release: Application, etc? That at least seems like a VS Code click and make this happen way. I don't want to change the configure step, I want to get a variable to the build step, so I'm not entirely sure this is right anyhow.

[bobbrow]

I would recommend CMake Presets for this. You basically create two configurePresets that define how you want CMake to generate your cache. Then you create buildPresets that will build your differently configured projects (perhaps with additional variations).

If you use Presets, then you select the one you want to be active (instead of selecting Kits) and the extension will behave the way you expect. If you set it up this way, then you only need one config in c_cpp_properties.json that looks more or less like this:

{
  "name": "myConfig",
  "configurationProvider": "ms-vscode.cmake-tools"
}

You can still set compilerPath, includePath, defines, etc as backups in case you're working with a source file that's not described by your CMake project, but it isn't always necessary.

[bobbrow]

BTW, if you get stuck we might be able to help you write your presets if you share your c_cpp_properties.json.

[jnz86]

Thanks so much for your help! Really appreciate it.

I only regret that I'm not sure when/how I would have found this info on my own. I love the how-to.md and did see that before coming here. If there had been an entry that said "I want to build two very different applications from the same sources" and then discussed preset that would have helped. Probably would have found presets if I had kept reading the readme.

Lastly, I have some trouble getting the actual -DKEY=VALUE using presets. I can't see how to get variables into CMake without putting them in "cacheVariables". Which is fine, but that only seems to work if you put it in the configPresets, not the buildPresets. So I can have my four options as configPresets, but can't seem to get DEBUG/RELEASE as a config, and BOOTLOADER/APPLICATION as build, or vice versa. I can't have

      {
        "name": "debug",
        "displayName": "Debug,
        "description": "DebugGCC Configuration",
        "inherits": "base",
        "cacheVariables": {
          "BUILD_CFG": "BOOTLOADER" <---- I can't put this here
          "CMAKE_BUILD_TYPE": "debug"
        }
      },
    ],
    "buildPresets": [
      {
        "name": "bootloader_debug",
        "displayName": "Bootloader",
        "configurePreset": "debug",         <----- But I need it to be referenced here
        "inherits" : "bootloader_variables",
        "description": "Development bootloader build"
      },

[bobbrow]

Are you talking about a preprocessor define that you're trying to send to the compiler? cacheVariables in the configure preset are the -DKEY=VALUE items that you send to cmake for configuration. If you are looking to pass a -DKEY=VALUE to the compiler in the build preset, you want to use nativeToolOptions. Or better, create a cache variable for them and set the target flags in your CMakeLists.txt conditionally based on the presence of that cache variable instead.

Please also note that CMAKE_BUILD_TYPE should be "Debug" with a capital "D" unless you have defined your own custom build type with a lower case "d".

[jnz86]

Bob, that is very helpful and I immensely appreciate the fast response. I‘be just skimmed the docs https://github.com/microsoft/vscode-cmake-tools/blob/main/docs/cmake-presets.md That does look like what I want. Although I didn’t see if there was a way to see this from the VS Code UI like the kit and variant. No big deal if not.I’ll enable presets, and update when I get it working. ps> The example at the bottom of the markdown link is 404

[bobbrow]

I fixed the link. Thanks.
Presets buttons will replace the Kits buttons on the status bar when you enable it. We don't allow mixing Kits with Presets.

[bobbrow]

We don't allow mixing Kits with Presets.

But we do have a command to create a configure preset from an existing Kit.

[jnz86]

Fwiw, I'm not seeing exactly how to create a preset from a kit. I see from toolchain file, from compiler (which my ARM GCC isn't listed under), and custom that I fill in myself.

All that my kit contains is:

[
    {
        "name": "ARM GCC Embedded",
        "toolchainFile": "${workspaceRoot}/arm-none-eabi-gcc.cmake"
    }
]

So I think I'll get by. But for the next person it might be helpful to know how to do that.

[bobbrow]

"from compiler" is the option that lets you pick one of your Kits. But I don't think it pulls the toolchain out of an existing Kit because we don't generate toolchain-based Kits for you.

[jnz86]

I’ll look into that. Basically I don’t care how it gets done, I just want to get some custom flag inside I can reference inside CMakeList.txt. I created BUILD_CFG to pass `APPLICATION` or `BOOTLOADER` The only way I can get it in is in the configure section which creates a selection problem. I saw nativeOption but couldn’t figure out how to get that as a variable to reference inside the lists.txt. Should I still pursue the nativeOption field?

[bobbrow]

If you're passing it to cmake and using conditional logic in CMakeLists.txt based on the value, then it's a cacheVariable. The split you define takes place when you configure. You'll want to keep both "configured" projects separate, so you should use something like this in your configurePresets to keep a cache for each configuration:

    "binaryDir": "${sourceDir}/out/build/${presetName}",

I'll post an example with my guesses as to what I think you want to do.

[bobbrow]

Note that depending on the generator you use, you may or may not need build presets. If you use single-config generators like "Ninja" or "Unix Makefiles", then you don't need build presets. If you use multi-config generators like "Visual Studio ..." or "Ninja Multi-Config", then you need fewer configure presets, but will need to add build presets to select the build type (e.g. Debug|Release)

{
    "version": 4,
    "configurePresets": [
        {
            "name": "base",
            "generator": "Unix Makefiles",
            "hidden": true,
            "binaryDir": "${sourceDir}/build/${presetName}"
        },
        {
            "name": "APPLICATION-base",
            "inherits": [ "base" ],
            "hidden": true,
            "cacheVariables": { "BUILD_CFG": "APPLICATION" }
        },
        {
            "name": "BOOTLOADER-base",
            "inherits": [ "base" ],
            "hidden": true,
            "cacheVariables": { "BUILD_CFG": "BOOTLOADER" }
        },
        {
            "name": "APPLICATION-Debug",
            "displayName": "...",
            "inherits": [ "APPLICATION-base" ],
            "cacheVariables": { "CMAKE_BUILD_TYPE": "Debug" }
        },
        {
            "name": "APPLICATION-Release",
            "displayName": "...",
            "inherits": [ "APPLICATION-base" ],
            "cacheVariables": { "CMAKE_BUILD_TYPE": "Release" }
        },
        {
            "name": "BOOTLOADER-Debug",
            "displayName": "...",
            "inherits": [ "BOOTLOADER-base" ],
            "cacheVariables": { "CMAKE_BUILD_TYPE": "Debug" }
        },
        {
            "name": "BOOTLOADER-Release",
            "displayName": "...",
            "inherits": [ "BOOTLOADER-base" ],
            "cacheVariables": { "CMAKE_BUILD_TYPE": "Release" }
        }
    ]
}

[jnz86]

Perfect. It helps to have someone who knows fill in what I suspected. This is great. I was being too focused on a config of Debug/Release and build of Boot/App. The simple words "then you don't need build presets" made a big difference. I'll keep it in mind for GCC flags or -v build, etc.

Bob, whatever they're paying you, it's not money wasted. Thanks a ton!

[bobbrow]

Then in your CMakeLists.txt, I assume you're doing something like this:

if (BUILD_CFG STREQUAL "APPLICATION")
  message(STATUS "APPLICATION")
  # APPLICATION-specific stuff
else()
  message(STATUS "BOOTLOADER")
  # BOOTLOADER-specific stuff
endif()

EDIT: I was working on this reply to follow up to my example. You replied to that before I got this one up. 😉

[jnz86]

Exactly… Although I used MATCHES instead of STREQUAL. Which I'll update to be more correct.