Comment diviser des chaînes sur plusieurs lignes dans CMake?

J'ai généralement une politique dans mon projet, de ne jamais créer de lignes dans les fichiers texte qui dépassent une longueur de ligne de 80, donc ils sont facilement modifiables dans toutes sortes d'éditeurs (vous connaissez l'affaire). Mais avec CMake, j'ai le problème que je ne sais pas comment diviser une simple chaîne en plusieurs lignes pour éviter une ligne énorme. Considérez ce code de base:

set(MYPROJ_VERSION_MAJOR "1")
set(MYPROJ_VERSION_MINOR "0")
set(MYPROJ_VERSION_PATCH "0")
set(MYPROJ_VERSION_EXTRA "rc1")
set(MYPROJ_VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}-${VERSION_EXTRA}")

Il dépasse déjà la limite de 80 lignes. Alors, comment diviser une ligne dans CMake en plusieurs lignes sans devenir verbeux (multiple list(APPEND ...)ou similaire)?

Mise à jour pour CMake 3.0 et plus récent :

la poursuite de la ligne est possible avec \. voir cmake-3.0-doc

message("\
This is the first line of a quoted argument. \
In fact it is the only line but since it is long \
the source code uses line continuation.\
")

Disponibilité des versions de CMake:

Debian Wheezy (2013): 2.8.9
Debian Wheezy-backports: 2.8.11
Debian Jessy (2015): 3.0.2
Ubuntu 14.04 (LTS): 2.8.12
Ubuntu 15.04: 3.0.2
Mac OSX: cmake-3 disponible via Homebrew , Macports et Fink
Windows: cmake-3 disponible via Chocolatey

CMake 3.0 et plus récent

Utilisez la string(CONCAT)commande:

set(MYPROJ_VERSION_MAJOR "1")
set(MYPROJ_VERSION_MINOR "0")
set(MYPROJ_VERSION_PATCH "0")
set(MYPROJ_VERSION_EXTRA "rc1")
string(CONCAT MYPROJ_VERSION "${MYPROJ_VERSION_MAJOR}"
                             ".${MYPROJ_VERSION_MINOR}"
                             ".${MYPROJ_VERSION_PATCH}"
                             "-${MYPROJ_VERSION_EXTRA}")

Bien que CMake 3.0 et les versions ultérieures prennent en charge la continuation des arguments entre guillemets , vous ne pouvez pas mettre en retrait la deuxième ou les lignes suivantes sans obtenir l'espace blanc d'indentation inclus dans votre chaîne.

CMake 2.8 et versions antérieures

Vous pouvez utiliser une liste. Chaque élément de la liste peut être mis sur une nouvelle ligne:

set(MYPROJ_VERSION_MAJOR "1")
set(MYPROJ_VERSION_MINOR "0")
set(MYPROJ_VERSION_PATCH "0")
set(MYPROJ_VERSION_EXTRA "rc1")
set(MYPROJ_VERSION_LIST "${MYPROJ_VERSION_MAJOR}"
                        ".${MYPROJ_VERSION_MINOR}"
                        ".${MYPROJ_VERSION_PATCH}"
                        "-${MYPROJ_VERSION_EXTRA}")

Une liste utilisée sans guillemets est concaténée sans espace blanc:

message(STATUS "Version: " ${MYPROJ_VERSION_LIST})
-- Version: 1.0.0-rc1

Si vous avez vraiment besoin d'une chaîne, vous pouvez d'abord convertir la liste en chaîne:

string(REPLACE ";" "" MYPROJ_VERSION "${MYPROJ_VERSION_LIST}")
message(STATUS "Version: ${MYPROJ_VERSION}")
-- Version: 1.0.0-rc1

Tous les points-virgules dans vos chaînes d'origine seront considérés comme des séparateurs d'éléments de liste et supprimés. Ils doivent être échappés:

set(MY_LIST "Hello World "
            "with a \;semicolon")

C'est encore un peu verbeux, mais si la limite de 80 caractères vous bogue vraiment, vous pouvez ajouter à plusieurs reprises la même variable:

set(MYPROJ_VERSION_MAJOR "1")
set(MYPROJ_VERSION_MINOR "0")
set(MYPROJ_VERSION_PATCH "0")
set(MYPROJ_VERSION_EXTRA "rc1")
set(MYPROJ_VERSION "${MYPROJ_VERSION_MAJOR}.")
set(MYPROJ_VERSION "${MYPROJ_VERSION}${MYPROJ_VERSION_MINOR}.")
set(MYPROJ_VERSION "${MYPROJ_VERSION}${MYPROJ_VERSION_PATCH}-")
set(MYPROJ_VERSION "${MYPROJ_VERSION}${MYPROJ_VERSION_EXTRA}")
message(STATUS "version: ${MYPROJ_VERSION}")

Donne sortie:

$ cmake  ~/project/tmp
-- version: 1.0.0-rc1
-- Configuring done
-- Generating done
-- Build files have been written to: /home/rsanderson/build/temp

Il n'existe aucun moyen de diviser un littéral de chaîne sur plusieurs lignes dans les fichiers CMakeLists.txt ou dans les scripts CMake. Si vous incluez une nouvelle ligne dans une chaîne, il y aura une nouvelle ligne littérale dans la chaîne elle-même.

# Don't do this, it won't work, MYPROJ_VERSION will contain newline characters:
set(MYPROJ_VERSION "${VERSION_MAJOR}.
  ${VERSION_MINOR}.${VERSION_PATCH}-
  ${VERSION_EXTRA}")

Cependant, CMake utilise des espaces pour séparer les arguments, vous pouvez donc changer un espace qui est un séparateur d'arguments en une nouvelle ligne où vous le souhaitez, sans changer le comportement.

Vous pouvez reformuler cette ligne plus longue:

set(MYPROJ_VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}-${VERSION_EXTRA}")

comme ces deux lignes plus courtes:

set(MYPROJ_VERSION
  "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}-${VERSION_EXTRA}")

Ils sont tout à fait équivalents.

L'exemple de la question d'origine ne concerne qu'une chaîne relativement courte. Pour les chaînes plus longues (y compris les exemples donnés dans d'autres réponses), un argument entre crochets pourrait être préférable. De la documentation:

Un crochet ouvrant est écrit [suivi de zéro ou plus =suivi de [. Le crochet fermant correspondant est écrit ]suivi du même nombre de =suivi de ]. Les supports ne s'emboîtent pas. Une longueur unique peut toujours être choisie pour que les crochets d'ouverture et de fermeture contiennent des crochets de fermeture d'autres longueurs.

[...]

Par exemple:

message([=[
This is the first line in a bracket argument with bracket length 1.
No \-escape sequences or ${variable} references are evaluated.
This is always one argument even though it contains a ; character.
The text does not end on a closing bracket of length 0 like ]].
It does end in a closing bracket of length 1.
]=])```

Pour ceux qui ont été amenés ici de Comment diviser une expression de générateur CMake en plusieurs lignes? Je voudrais ajouter quelques notes.

La méthode de continuation de ligne ne fonctionnera pas, CMake ne peut pas analyser une liste de générateurs faite avec des espaces (indentation) et une continuation de ligne.

Alors que la solution de chaîne (CONCAT) fournira une expression de générateur qui peut être évaluée, l'expression évaluée sera entourée de guillemets si le résultat contient un espace.

Pour chaque option individuelle à ajouter, une liste de générateurs distincte doit être construite, donc les options d'empilement comme je l'ai fait dans ce qui suit entraînera l'échec de la construction:

string(CONCAT WARNING_OPTIONS "$<"
    "$<OR:"
        "$<CXX_COMPILER_ID:MSVC>,"
        "$<STREQUAL:${CMAKE_CXX_SIMULATE_ID},MSVC>"
    ">:"
    "/D_CRT_SECURE_NO_WARNINGS "
">$<"
    "$<AND:"
        "$<CXX_COMPILER_ID:Clang,GNU>,"
        "$<NOT:$<STREQUAL:${CMAKE_CXX_SIMULATE_ID},MSVC>>"
    ">:"
    "-Wall -Werror "
">$<"
    "$<CXX_COMPILER_ID:GNU>:"
    "-Wno-multichar -Wno-sign-compare "
">")
add_compile_options(${WARNING_OPTIONS})

C'est parce que les options résultantes sont passées au compilateur entre guillemets

/usr/lib64/ccache/c++  -DGTEST_CREATE_SHARED_LIBRARY=1 -Dgtest_EXPORTS -I../ThirdParty/googletest/googletest/include -I../ThirdParty/googletest/googletest -std=c++11 -fno-rtti -fno-exceptions -fPIC    -std=c++11 -fno-rtti -fno-exceptions -Wall -Wshadow -DGTEST_HAS_PTHREAD=1 -fexceptions -Wextra -Wno-unused-parameter -Wno-missing-field-initializers "-Wall -Werror -Wno-multichar -Wno-sign-compare " -fdiagnostics-color -MD -MT ThirdParty/googletest/googletest/CMakeFiles/gtest.dir/src/gtest-all.cc.o -MF ThirdParty/googletest/googletest/CMakeFiles/gtest.dir/src/gtest-all.cc.o.d -o ThirdParty/googletest/googletest/CMakeFiles/gtest.dir/src/gtest-all.cc.o -c ../ThirdParty/googletest/googletest/src/gtest-all.cc
c++: error: unrecognized command line option ‘-Wall -Werror -Wno-multichar -Wno-sign-compare ’

Pour évaluer de longues expressions de générateur représentées à l'aide de la solution de chaîne (CONCAT), chaque expression de générateur doit s'évaluer en une seule option sans espaces:

string(CONCAT WALL "$<"
    "$<AND:"
        "$<CXX_COMPILER_ID:Clang,GNU>,"
        "$<NOT:$<STREQUAL:${CMAKE_CXX_SIMULATE_ID},MSVC>>"
    ">:"
    "-Wall"
">")
string(CONCAT WERROR "$<"
    "$<AND:"
        "$<CXX_COMPILER_ID:Clang,GNU>,"
        "$<NOT:$<STREQUAL:${CMAKE_CXX_SIMULATE_ID},MSVC>>"
    ">:"
    "-Werror"
">")
message(STATUS "Warning Options: " ${WALL} ${WERROR})
add_compile_options(${WALL} ${WERROR})

Cela n'a peut-être aucun rapport avec la question à laquelle je poste une réponse, malheureusement, la question à laquelle je réponds est à tort marquée comme un double de cette question.

Les listes de générateurs ne sont pas gérées et analysées de la même manière que les chaînes, et pour cette raison, il existe des mesures supplémentaires à prendre pour diviser une liste de générateurs sur plusieurs lignes.

Pour maintenir une bonne indentation dans votre code, il suffit de faire

message("These strings " "will all be "
        "concatenated. Don't forget "
        "your trailing spaces!")

Ou formez une chaîne directement avec

string(CONCAT MYSTR "This and " "that "
                    "and me too!")

comme dans la réponse de Douglas qui a plus de détails. Cependant, j'ai pensé que cela pourrait simplement résumer le point essentiel.