Dela via

CMakeSettings.json schemareferens

CMake-projekt stöds i Visual Studio 2017 och senare.

Filen CMakeSettings.json innehåller information som Visual Studio använder för IntelliSense och för att konstruera de kommandoradsargument som skickas till CMake för en angiven konfigurations- och kompilatormiljö. En konfiguration anger egenskaper som gäller för en specifik plattform och byggtyp, till exempel x86-Debug eller Linux-Release. Varje konfiguration anger en miljö som kapslar in information om kompilatorverktygen, till exempel MSVC, GCC eller Clang. CMake använder kommandoradsargumenten för att återskapa rotfilen CMakeCache.txt och andra projektfiler för projektet. Värdena kan åsidosättas i CMakeLists.txt filerna.

Du kan lägga till eller ta bort konfigurationer i IDE och sedan redigera dem direkt i JSON-filen eller använda CMake Settings-redigeraren (Visual Studio 2019 och senare). Du kan enkelt växla mellan konfigurationerna i IDE för att generera de olika projektfilerna. Mer information finns i Anpassa CMake-bygginställningar i Visual Studio.

-konfigurationer

Matrisen configurations innehåller alla konfigurationer för ett CMake-projekt. Mer information om de fördefinierade konfigurationerna finns i CMake-fördefinierad konfigurationsreferens. Du kan lägga till valfritt antal fördefinierade eller anpassade konfigurationer i filen.

A configuration har följande egenskaper:

  • addressSanitizerEnabled: Om true om kompilerar programmet med hjälp av AddressSanitizer. I Linux kompilerar du med -fno-omit-frame-pointer och kompileraroptimeringsnivå -Os eller -Oo för bästa resultat.

  • addressSanitizerRuntimeFlags: Körningsflaggor som skickas med till AddressSanitizer i ASAN_OPTIONS miljövariabeln. Format: flag1=value:flag2=value2.

  • buildCommandArgs: Anger interna build-växlar som skickas till CMake efter --build --. Om du till exempel skickar -v när du använder Ninja-generatorn tvingar du Ninja att mata ut kommandorader. Mer information om Ninja-kommandon finns i Ninja-kommandoradsargument.

  • buildRoot: Anger den katalog där CMake genererar byggskript för den valda generatorn. Kopplar till -DCMAKE_BINARY_DIR och anger var CMakeCache.txt skapas. Om mappen inte finns skapas den. Makron som stöds är ${workspaceRoot}, ${workspaceHash}, ${projectFile}, ${projectDir}, ${thisFile}, ${thisFileDir}, ${name}, ${generator}, ${env.VARIABLE}.

  • cacheGenerationCommand: Anger ett kommandoradsverktyg och argument, till exempel gencache.bat debug för att generera cacheminnet. Kommandot körs från gränssnittet i den angivna miljön för konfigurationen när användaren uttryckligen begär regenerering eller en CMakeLists.txt fil CMakeSettings.json ändras.

  • cacheRoot: Anger sökvägen till en CMake-cache. Den här katalogen bör innehålla en befintlig CMakeCache.txt fil.

  • clangTidyChecks: kommaavgränsad lista över varningar som skickas till clang-tidy; jokertecken tillåts och prefixet '-' tar bort granskningar.

  • cmakeCommandArgs: Anger eventuella extra kommandoradsalternativ som ska skickas till CMake när de anropas för att generera projektfilerna.

  • cmakeToolchain: Anger verktygskedjans fil. Den skickas till CMake med hjälp av -DCMAKE_TOOLCHAIN_FILE.

  • codeAnalysisRuleset: Anger den regeluppsättning som ska användas när kodanalys körs. Du kan använda en fullständig sökväg eller filnamnet för en regeluppsättningsfil som installerats av Visual Studio.

  • configurationType: Anger konfigurationen av byggtyp för den valda generatorn. Kan vara något av:

    • Debug
    • Release
    • MinSizeRel
    • RelWithDebInfo

  • ctestCommandArgs: Anger eventuella extra kommandoradsalternativ som ska skickas till CTest när testerna körs.

  • description: Beskrivningen av den här konfigurationen som visas i menyer.

  • enableClangTidyCodeAnalysis: Använd Clang-Tidy för kodanalys.

  • enableMicrosoftCodeAnalysis: Använd Microsofts kodanalysverktyg för kodanalys.

  • generator: Anger vilken CMake-generator som ska användas för den här konfigurationen. Kan vara något av:

    Endast Visual Studio 2019:

    • Visual Studio 16 2019
    • Visual Studio 16 2019 Win64
    • Visual Studio 16 2019 ARM

    Visual Studio 2017 och senare:

    • Visual Studio 15 2017
    • Visual Studio 15 2017 Win64
    • Visual Studio 15 2017 ARM
    • Visual Studio 14 2015
    • Visual Studio 14 2015 Win64
    • Visual Studio 14 2015 ARM
    • Unix Makefiles
    • Ninja

Eftersom Ninja är utformad för snabba bygghastigheter i stället för flexibilitet och funktion anges den som standard. Vissa CMake-projekt kan dock inte byggas korrekt med hjälp av Ninja. Om ett byggfel inträffar kan du instruera CMake att generera Visual Studio-projekt i stället.

Om du vill ange en Visual Studio-generator i Visual Studio 2017 öppnar du inställningsredigeraren från huvudmenyn genom att välja CMake | Ändra CMake-inställningar. Ta bort "Ninja" och ange "V". Den här ändringen aktiverar IntelliSense, vilket gör att du kan välja önskad generator.

Om du vill ange en Visual Studio-generator i Visual Studio 2019 högerklickar du på CMakeLists.txt filen i Solution Explorer och väljer CMake-inställningar för projektet>Visa avancerade inställningar>CMake Generator.

När den aktiva konfigurationen som standard anger en Visual Studio-generator anropar den MSBuild med -m -v:minimal argument. För att anpassa versionen, använd egenskapen buildCommandArgs i filen CMakeSettings.json. Här kan du ange MSBuild-kommandoradsargument som ska skickas till byggsystemet:

"buildCommandArgs": "-m:8 -v:minimal -p:PreferredToolArchitecture=x64"

  • installRoot: Anger den katalog där CMake genererar installationsmål för den valda generatorn. Makron som stöds är ${workspaceRoot}, ${workspaceHash}, ${projectFile}, ${projectDir}, ${thisFile}, ${thisFileDir}, ${name}, ${generator}, ${env.VARIABLE}.

  • inheritEnvironments: Anger en eller flera kompilatormiljöer som den här konfigurationen är beroende av. Kan vara en anpassad miljö eller en av de fördefinierade miljöerna. Mer information finns i Miljöer.

  • intelliSenseMode: Anger det läge som används för att beräkna intellisense-information". Värdet kan vara något av:

    • windows-msvc-x86
    • windows-msvc-x64
    • windows-msvc-arm
    • windows-msvc-arm64
    • android-clang-x86
    • android-clang-x64
    • android-clang-arm
    • android-clang-arm64
    • ios-clang-x86
    • ios-clang-x64
    • ios-clang-arm
    • ios-clang-arm64
    • windows-clang-x86
    • windows-clang-x64
    • windows-clang-arm
    • windows-clang-arm64
    • linux-gcc-x86
    • linux-gcc-x64
    • linux-gcc-arm

  • name: namnger konfigurationen. Mer information om de fördefinierade konfigurationerna finns i CMake-fördefinierad konfigurationsreferens.

  • wslPath: sökvägen till startprogrammet för en instans av Windows-undersystemet för Linux.

Inställningar för CMake Linux-projekt

  • remoteMachineName: Anger namnet på den fjärranslutna Linux-dator som är värd för CMake, versioner och felsökningsprogrammet. Använd Anslutningshanteraren för att lägga till nya Linux-datorer. Makron som stöds är ${defaultRemoteMachineName}.
  • remoteCopySourcesOutputVerbosity: Anger utförlighetsnivån för källkopieringsåtgärden till fjärrdatorn. Kan vara en av Normal, Verboseeller Diagnostic.
  • remoteCopySourcesConcurrentCopies: Anger de samtidiga kopior som ska användas under synkroniseringen av källorna till fjärrdatorn (endast sftp).
  • remoteCopySourcesMethod: Anger metoden för att kopiera filer till fjärrdatorn. Kan vara rsync eller sftp.
  • remoteCMakeListsRoot: Anger katalogen på fjärrdatorn som innehåller CMake-projektet. Makron som stöds är ${workspaceRoot}, ${workspaceHash}, ${projectFile}, ${projectDir}, ${thisFile}, ${thisFileDir}, ${name}, ${generator}och ${env.VARIABLE}.
  • remoteBuildRoot: Anger katalogen på fjärrdatorn där CMake genererar byggskript för den valda generatorn. Makron som stöds är ${workspaceRoot}, ${workspaceHash}, ${projectFile}, ${projectDir}, ${thisFile}, ${thisFileDir}, ${name}, ${generator}, ${env.VARIABLE}.
  • remoteInstallRoot: Anger katalogen på fjärrdatorn där CMake genererar installationsmål för den valda generatorn. Makron som stöds är ${workspaceRoot}, ${workspaceHash}, ${projectFile}, ${projectDir}, ${thisFile}, ${thisFileDir}, ${name}, ${generator}och ${env.VARIABLE}, där VARIABLE är en miljövariabel som har definierats på system-, användar- eller sessionsnivå.
  • remoteCopySources: En boolean som anger om Visual Studio ska kopiera källfiler till fjärrdatorn. Standardvärdet är sant. Ange till false om du hanterar filsynkronisering själv.
  • remoteCopyBuildOutput: En boolean som anger om byggresultaten ska kopieras från fjärrsystemet.
  • remoteCopyAdditionalIncludeDirectories: Ytterligare inkluderar kataloger som ska kopieras från fjärrdatorn för att stödja IntelliSense. Formatera som "/path1;/path2...".
  • remoteCopyExcludeDirectories: Inkludera kataloger SOM INTE ska kopieras från fjärrdatorn. Formatera som "/path1;/path2...".
  • remoteCopyUseCompilerDefaults: Anger huruvida kompilatorns standarddefinitionsalternativ och inkluderingssökväg ska användas för IntelliSense. Bör bara vara falskt om kompilatorerna som används inte stöder gcc-liknande argument.
  • rsyncCommandArgs: Anger en uppsättning kommandoradsalternativ som skickas till rsync.
  • remoteCopySourcesExclusionList: En array som anger en lista över sökvägar som ska undantas när källfiler kopieras: en sökväg kan vara namnet på en fil/katalog eller en relativ sökväg från kopians rot. Jokertecken * och ? kan användas för matchning av globmönster.
  • cmakeExecutable: Anger den fullständiga sökvägen till det körbara CMake-programmet, inklusive filnamnet och filnamnstillägget.
  • remotePreGenerateCommand: Anger kommandot som ska köras innan CMake körs för att parsa CMakeLists.txt filen.
  • remotePrebuildCommand: Anger kommandot som ska köras på fjärrdatorn innan du skapar.
  • remotePostbuildCommand: Anger kommandot som ska köras på fjärrdatorn när du har skapat.
  • variables: Innehåller ett namn/värde-par med CMake-variabler som -D name=value skickas till CMake. Om bygginstruktionerna för ditt CMake-projekt specificerar att variabler ska läggas direkt till CMakeCache.txt-filen, rekommenderar vi att du i stället lägger till dem här. Det här exemplet visar hur du anger namn/värde-paren för att använda 14.14.26428 MSVC Build Tools:
"variables": [
    {
      "name": "CMAKE_CXX_COMPILER",
      "value": "C:/Program Files (x86)/Microsoft Visual Studio/157/Enterprise/VC/Tools/MSVC/14.14.26428/bin/HostX86/x86/cl.exe",
      "type": "FILEPATH"
    },
    {
      "name": "CMAKE_C_COMPILER",
      "value": "C:/Program Files (x86)/Microsoft Visual Studio/157/Enterprise/VC/Tools/MSVC/14.14.26428/bin/HostX86/x86/cl.exe",
      "type": "FILEPATH"
    }
  ]

Om du inte definierar "type""STRING" antas typen som standard.

  • remoteCopyOptimizations: Visual Studio 2019 version 16.5 eller senare egenskaper för att styra källkopian till fjärrmålet. Optimeringar är aktiverade som standard. Innehåller remoteCopyUseOptimizations, rsyncSingleDirectoryCommandArgsoch remoteCopySourcesMaxSmallChange.

Miljöer

En miljö kapslar in miljövariablerna som anges i den process som Visual Studio använder för att anropa CMake. För MSVC-projekt avbildas variablerna som anges i en kommandotolk för utvecklare för en specifik plattform. Miljön är till exempel msvc_x64_x64 densamma som när du kör kommandotolken för utvecklare för VS {version} med argumenten -arch=amd64 -host_arch=amd64 . Du kan använda syntaxen env.{<variable_name>} i CMakeSettings.json för att referera till de enskilda miljövariablerna, till exempel för att konstruera sökvägar till mappar. Följande fördefinierade miljöer tillhandahålls:

  • linux_arm: Rikta in på ARM Linux på distans.
  • linux_x64: Fjärrmåla x64 Linux.
  • linux_x86: Rikta in sig på x86 Linux på distans.
  • msvc_arm: Rikta ARM Windows med MSVC-kompilatorn.
  • msvc_arm_x64: Sikta på ARM Windows med 64-bitars MSVC-kompilatorn.
  • msvc_arm64: Rikta mot ARM64 Windows med användning av MSVC-kompilatorn.
  • msvc_arm64_x64: Rikta mot Windows för ARM64 med 64-bitars MSVC-kompilator.
  • msvc_arm64ec: Mål ARM64EC Windows med MSVC-kompilatorn.
  • msvc_arm64ec_x64: Rikta in dig på ARM64EC Windows med den 64-bitars MSVC-kompilatorn.
  • msvc_x64: Rikta x64 Windows mot MSVC-kompilatorn.
  • msvc_x64_x64: Sikta på x64 Windows med 64-bitars MSVC-kompilatorn.
  • msvc_x86: Rikta x86 Windows med MSVC-kompilatorn.
  • msvc_x86_x64: Rikta mot x86 Windows med 64-bitars MSVC-kompilatorn.

Komma åt miljövariabler från CMakeLists.txt

Från en CMakeLists.txt fil refereras alla miljövariabler med syntaxen $ENV{variable_name}. Om du vill se tillgängliga variabler för en miljö öppnar du motsvarande kommandotolk och skriver SET. En del av informationen i miljövariabler är också tillgänglig via CMake-systemintrospektionsvariabler, men det kan vara enklare att använda miljövariabeln. Du kan till exempel enkelt hämta MSVC-kompilatorversionen eller Windows SDK-versionen via miljövariablerna.

Anpassade miljövariabler

I CMakeSettings.jsonkan du definiera anpassade miljövariabler globalt eller per konfiguration i matrisen environments . En anpassad miljö är ett bekvämt sätt att gruppera en uppsättning egenskaper. Du kan använda den i stället för en fördefinierad miljö, eller för att utöka eller ändra en fördefinierad miljö. Varje objekt i matrisen environments består av:

  • namespace: Namnger miljön så att dess variabler kan refereras från en konfiguration i formuläret namespace.variable. Standardmiljöobjektet anropas env och fylls i med vissa systemmiljövariabler, inklusive %USERPROFILE%.
  • environment: Identifierar unikt den här gruppen med variabler. Tillåter att gruppen ärvs senare i en inheritEnvironments post.
  • groupPriority: Ett heltal som anger prioriteten för dessa variabler när de utvärderas. Objekt med högre antal utvärderas först.
  • inheritEnvironments: En matris med värden som anger den uppsättning miljöer som ärvs av den här gruppen. Med den här funktionen kan du ärva standardmiljöer och skapa anpassade miljövariabler som skickas till CMake när den körs.

Visual Studio 2019 version 16.4 och senare: Felsökningsmål startas automatiskt med den miljö som du anger i CMakeSettings.json. Du kan åsidosätta eller lägga till miljövariabler per mål eller per uppgift i launch.vs.json och tasks.vs.json.

I följande exempel definieras en global variabel, BuildDir, som ärvs i konfigurationerna x86-Debug och x64-Debug. Varje konfiguration använder variabeln för att ange värdet för buildRoot-egenskapen för just den konfigurationen. Observera också hur varje konfiguration använder inheritEnvironments egenskapen för att ange en variabel som endast gäller för den konfigurationen.

{
  // The "environments" property is an array of key-value pairs of the form
  // { "EnvVar1": "Value1", "EnvVar2": "Value2" }
  "environments": [
    {
      "BuildDir": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\build",
    }
  ],

  "configurations": [
    {
      "name": "x86-Debug",
      "generator": "Ninja",
      "configurationType": "Debug",
      // Inherit the defaults for using the MSVC x86 compiler.
      "inheritEnvironments": [ "msvc_x86" ],
      "buildRoot": "${env.BuildDir}\\${name}"    },
    {
      "name": "x64-Debug",
      "generator": "Ninja",
      "configurationType": "Debug",
      // Inherit the defaults for using the MSVC x64 compiler.
      "inheritEnvironments": [ "msvc_x64" ],
      "buildRoot": "${env.BuildDir}\\${name}"
    }
  ]
}

I nästa exempel definierar konfigurationen x86-Debug sitt eget värde för egenskapen BuildDir . Det här värdet åsidosätter värdet som anges av den globala BuildDir-egenskapen så att BuildRoot utvärderas till D:\custom-builddir\x86-Debug.

{
  "environments": [
    {
      "BuildDir": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}",
    }
  ],

  "configurations": [
    {
      "name": "x86-Debug",

      // The syntax for this property is the same as the global one above.
      "environments": [
        {
          // Replace the global property entirely.
          "BuildDir": "D:\\custom-builddir"
          // This environment does not specify a namespace, hence by default "env" is assumed.
          // "namespace" : "name" would require that this variable be referenced with "${name.BuildDir}".
        }
      ],

      "generator": "Ninja",
      "configurationType": "Debug",
      "inheritEnvironments": [ "msvc_x86" ],
      // Evaluates to "D:\custom-builddir\x86-Debug"
      "buildRoot": "${env.BuildDir}\\${name}"
    },
    {
      "name": "x64-Debug",

      "generator": "Ninja",
      "configurationType": "Debug",
      "inheritEnvironments": [ "msvc_x64" ],
      // Since this configuration doesn't modify BuildDir, it inherits
      // from the one defined globally.
      "buildRoot": "${env.BuildDir}\\${name}"
    }
  ]
}

Makron

Följande makron kan användas i CMakeSettings.json:

  • ${workspaceRoot} – den fullständiga sökvägen till arbetsytans mapp
  • ${workspaceHash} – hash för arbetsytans plats. användbart för att skapa en unik identifierare för den aktuella arbetsytan (till exempel för att använda i mappsökvägar)
  • ${projectFile} – rotfilens CMakeLists.txt fullständiga sökväg
  • ${projectDir}– den fullständiga sökvägen till mappen som innehåller rotfilen CMakeLists.txt
  • ${projectDirName}– namnet på mappen som innehåller rotfilen CMakeLists.txt
  • ${thisFile} – filens CMakeSettings.json fullständiga sökväg
  • ${name} – namnet på konfigurationen
  • ${generator} – namnet på CMake-generatorn som används i den här konfigurationen

Alla referenser till makron och miljövariabler i CMakeSettings.json expanderas innan de skickas till CMake-kommandoraden.

Ninja-kommandoradsargument

Om målen är ospecificerade skapar Ninja standardmålet.

C:\Program Files (x86)\Microsoft Visual Studio\Preview\Enterprise>ninja -?
ninja: invalid option -- `-?'
usage: ninja [options] [targets...]
Alternativ Beskrivning
--version Skriv ut ninja version ("1.7.1")
-C DIR Ändra till DIR innan du gör något annat
-f FILE Ange indatakompileringsfil (standard=build.ninja)
-j N Köra N jobb parallellt (default=14, härledd från tillgängliga processorer)
-k N Fortsätt tills N jobben misslyckas (standard=1)
-l N Starta inte nya jobb om belastningsgenomsnittet är större än N
-n Testsimulering (utför inte kommandon men agerar som om de lyckades)
-v Visa alla kommandorader när du skapar
-d MODE Aktivera felsökning (använd -d list för att lista lägen)
-t TOOL Kör ett underverktyg (använd -t list för att lista underverktygen). Avslutar alla alternativ på den översta nivån. ytterligare flaggor skickas till verktyget
-w FLAG Justera varningar (använd -w list för att lista varningar)
  • Last updated on