La fonction vs Macro dans CMake

Le document officiel de CMake 2.8.12 dit à propos de macro

Lorsqu'elle est invoquée, les commandes enregistrées dans la macro sont d'abord
modifié en remplaçant les paramètres formels (${arg1}) avec les arguments
passé et puis invoquée comme normal commandes.

et sur function

Lorsqu'elle est invoquée, les commandes enregistrées dans la fonction sont d'abord
modifié en remplaçant les paramètres formels (${arg1}) avec les arguments
passé et puis invoquée comme normal commandes.

Évidemment, les deux citations sont presque la même, mais me confondre. Ne remplacer les paramètres d'abord, lorsque l'appel d'une fonction comme macro?

  • Il y a au moins un autre important, quoique de façon assez évidente différence entre function et macro: la sémantique de return(): Lorsqu'il est utilisé dans un macro, vous n'aurez pas de retour à partir de la macro, mais à partir de la fonction appelante.
  • Une autre remarque importante, c'est qu'une macro ont deux passes phase d'expansion sur des arguments lorsqu'une fonction est un seul. Essayez de créer ces macro et de la fonction, et l'impression de l' ${ARGV} de l'intérieur: macro(my_macro), function(my_func). Et de les utiliser: set(a 123), my_macro("\\\${a}\\\\;\\\;;") , my_func(\${a}\\;\;;). Vous trouverez que vous avez à double échapper à toutes les $, \ , ; pour bien passer toute la chaîne inchangé pour les commandes imbriquées. Ce qui est réel dans le cmake 3.14+.
InformationsquelleAutor Yantao Xie | 2014-06-19
  1. 81

    J'ai écrit un exemple de code ci-dessous:

    set(var "ABC")

macro(Moo arg)
  message("arg = ${arg}")
  set(arg "abc")
  message("# After change the value of arg.")
  message("arg = ${arg}")
endmacro()
message("=== Call macro ===")
Moo(${var})

function(Foo arg)
  message("arg = ${arg}")
  set(arg "abc")
  message("# After change the value of arg.")
  message("arg = ${arg}")
endfunction()
message("=== Call function ===")
Foo(${var})

    et la sortie est: 

    === Call macro ===
arg = ABC
# After change the value of arg.
arg = ABC
=== Call function ===
arg = ABC
# After change the value of arg.
arg = abc

    Il semble donc arg est affectée de la valeur de var lors de l'appel de Foo et ${arg} est juste de la chaîne remplacé par ${var} lors de l'appel de Moo.

    Donc je pense que les deux ci-dessus citations sont très faciles à faire confuse, bien que les documents officiels également dit que:

    Ils sont de la chaîne de remplacement comme le préprocesseur C ferais
    avec une macro. Si vous voulez un vrai variables CMake et/ou mieux CMake
    la portée du contrôle que vous devriez regarder la fonction de commande.

    • J'ai oublié, mais je pense qu'il peut être.
    • ma question était de savoir poster une question juste pour répondre immédiatement, pas sur le point de demander, de faire de la recherche et, enfin, d'y répondre.
    • Répondre à votre propre question immédiatement est permise par le Centre d'Aide (surtout si c'est un bon, de non-double question d'intérêt général pour les autres). C'est à l'aide, AFIN de devenir une meilleure base de connaissances. Avez-vous lu le post de blog lié dans ce Centre d'Aide sujet? stackoverflow.blog/2011/07/01/...
    • Je suis juste le relais de ce que le fondateur de lui-même pense à propos de cette pratique. Le prendre avec lui. 😉
    • Je pense qu'il est important de noter ce qui se passe à arg hors de portée. Parce que pour la fonction arg=" " et pour la macro arg=abc est vrai.
    • L'exécution de tels exemples avec cmake --trace-expand est éclairant
    • Veuillez envisager d'ajouter la commande suivante après chaque appel: message("# arg in main scope = '${arg}'") + l'appel de la fonction avant de la macro.

    InformationsquelleAutor Yantao Xie
  2. 29

    En d'autres termes, la fonction de la pousse et de la pop de la nouvelle portée des variables (variables de créer et de modifier n'existent que dans la fonction), la macro ne fonctionne pas. Toutefois, vous pouvez remplacer la fonction par défaut, le comportement avec le PARENT_SCOPE paramètre de la set commande.

    InformationsquelleAutor robert
  3. 5

    La documentation de cmake que vous avez cité est si trompeur qu'il est fondamentalement erroné. Il convient de préciser/fixe comme ceci:

    • macro: lorsqu'elle est invoquée, les commandes enregistrées dans la macro sont de la première de toutes modifiés avant tout est exécuté en remplaçant les paramètres formels (${arg1}) avec les arguments passés.

    cmake --trace-expand montre exactement ce qui se passe.

    Le cmake 3.13.3 doc n'a pas changé par rapport à 2.8.12 à cet égard.

    InformationsquelleAutor MarcH