Est-il possible de créer une variable de chaîne multiligne dans un Makefile

Je veux créer une variable makefile qui est une chaîne multiligne (par exemple le corps d'une annonce de publication par e-mail). quelque chose comme

ANNOUNCE_BODY="
Version $(VERSION) of $(PACKAGE_NAME) has been released

It can be downloaded from $(DOWNLOAD_URL)

etc, etc"

Mais je n'arrive pas à trouver un moyen de le faire. C'est possible?

Oui, vous pouvez utiliser le mot-clé define pour déclarer une variable multiligne, comme ceci:

define ANNOUNCE_BODY
Version $(VERSION) of $(PACKAGE_NAME) has been released.

It can be downloaded from $(DOWNLOAD_URL).

etc, etc.
endef

La partie délicate est de récupérer votre variable multiligne du makefile. Si vous faites simplement la chose évidente d'utiliser "echo $ (ANNOUNCE_BODY)", vous verrez le résultat que d'autres ont posté ici - le shell essaie de gérer la deuxième ligne et les suivantes de la variable comme des commandes.

Cependant, vous pouvez exporter la valeur de la variable telle quelle vers le shell en tant que variable d'environnement, puis la référencer depuis le shell en tant que variable d'environnement (PAS une variable de fabrication). Par exemple:

export ANNOUNCE_BODY
all:
    @echo "$$ANNOUNCE_BODY"

Notez l'utilisation de $$ANNOUNCE_BODY, indiquant une référence de variable d'environnement shell, plutôt que $(ANNOUNCE_BODY), qui serait une référence de variable make régulière. Veillez également à utiliser des guillemets autour de votre référence de variable, pour vous assurer que les retours à la ligne ne sont pas interprétés par le shell lui-même.

Bien sûr, cette astuce particulière peut être sensible à la plate-forme et au shell. Je l'ai testé sur Ubuntu Linux avec GNU bash 3.2.13; YMMV.

Une autre approche pour «récupérer votre variable multiligne du makefile» (noté par Eric Melski comme «la partie délicate»), consiste à prévoir d'utiliser la substfonction pour remplacer les nouvelles lignes introduites par definedans votre chaîne multiligne par \n. Utilisez ensuite -e avec echopour les interpréter. Vous devrez peut-être définir le .SHELL = bash pour obtenir un écho qui fait cela.

Un avantage de cette approche est que vous mettez également d'autres caractères d'échappement de ce type dans votre texte et que vous les faites respecter.

Ce genre de synthétise toutes les approches mentionnées jusqu'à présent ...

Vous vous retrouvez avec:

define newline


endef

define ANNOUNCE_BODY=
As of $(shell date), version $(VERSION) of $(PACKAGE_NAME) has been released.  

It can be downloaded from $(DOWNLOAD_URL).  

endef

someTarget:
    echo -e '$(subst $(newline),\n,${ANNOUNCE_BODY})'

Notez que les guillemets simples sur l'écho final sont cruciaux.

En supposant que vous souhaitiez uniquement imprimer le contenu de votre variable sur la sortie standard, il existe une autre solution:

do-echo:
    $(info $(YOUR_MULTILINE_VAR))

Oui. Vous échappez aux nouvelles lignes avec \:

VARIABLE="\
THIS IS A VERY LONG\
TEXT STRING IN A MAKE VARIABLE"

mettre à jour

Ah, tu veux les nouvelles lignes? Alors non, je ne pense pas qu'il y ait moyen de faire vanille. Cependant, vous pouvez toujours utiliser un document ici dans la partie commande

[Cela ne fonctionne pas, voir le commentaire de MadScientist]

foo:
    echo <<EOF
    Here is a multiple line text
    with embedded newlines.
    EOF

Juste un post-scriptum à la réponse d'Eric Melski: Vous pouvez inclure la sortie des commandes dans le texte, mais vous devez utiliser la syntaxe Makefile "$ (shell foo)" plutôt que la syntaxe shell "$ (foo)". Par exemple:

define ANNOUNCE_BODY  
As of $(shell date), version $(VERSION) of $(PACKAGE_NAME) has been released.  

It can be downloaded from $(DOWNLOAD_URL).  

endef

Cela ne donne pas de document ici, mais affiche un message sur plusieurs lignes d'une manière adaptée aux tuyaux.

=====

MSG = this is a\\n\
multi-line\\n\
message

method1:
     @$(SHELL) -c "echo '$(MSG)'" | sed -e 's/^ //'

=====

Vous pouvez également utiliser les macros appelables de Gnu:

=====

MSG = this is a\\n\
multi-line\\n\
message

method1:
        @echo "Method 1:"
        @$(SHELL) -c "echo '$(MSG)'" | sed -e 's/^ //'
        @echo "---"

SHOW = $(SHELL) -c "echo '$1'" | sed -e 's/^ //'

method2:
        @echo "Method 2:"
        @$(call SHOW,$(MSG))
        @echo "---"

=====

Voici le résultat:

=====

$ make method1 method2
Method 1:
this is a
multi-line
message
---
Method 2:
this is a
multi-line
message
---
$

=====

Pourquoi n'utilisez-vous pas le caractère \ n dans votre chaîne pour définir la fin de ligne? Ajoutez également la barre oblique inverse supplémentaire pour l'ajouter sur plusieurs lignes.

ANNOUNCE_BODY=" \n\
Version $(VERSION) of $(PACKAGE_NAME) has been released \n\
\n\
It can be downloaded from $(DOWNLOAD_URL) \n\
\n\
etc, etc"

Manuel GNU `make ', 6.8: Définition de variables multilignes

Vous devez utiliser "define / endef" Make construct:

define ANNOUNCE_BODY
Version $(VERSION) of $(PACKAGE_NAME) has been released.

It can be downloaded from $(DOWNLOAD_URL).

etc, etc.
endef

Ensuite, vous devez passer la valeur de cette variable à la commande shell. Mais, si vous faites cela en utilisant la substitution de variable, la commande se divisera en plusieurs:

ANNOUNCE.txt:
  echo $(ANNOUNCE_BODY) > $@               # doesn't work

Qouting n'aidera pas non plus.

La meilleure façon de transmettre une valeur est de la transmettre via la variable d'environnement:

ANNOUNCE.txt: export ANNOUNCE_BODY:=$(ANNOUNCE_BODY)
ANNOUNCE.txt:
  echo "$${ANNOUNCE_BODY}" > $@

Remarquer:

1. La variable est exportée pour cette cible particulière, de sorte que vous pouvez réutiliser cet environnement ne sera pas beaucoup pollué;
2. Utilisez la variable d'environnement (doubles qoutes et accolades autour du nom de la variable);
3. Utilisation de guillemets autour de la variable. Sans eux, les nouvelles lignes seront perdues et tout le texte apparaîtra sur une seule ligne.

Dans l'esprit du .ONESHELL, il est possible de se rapprocher assez près des environnements .ONESHELL contestés:

define _oneshell_newline_


endef

define oneshell
@eval "$$(printf '%s\n' '$(strip                            \
                         $(subst $(_oneshell_newline_),\n,  \
                         $(subst \,\/,                      \
                         $(subst /,//,                      \
                         $(subst ','"'"',$(1))))))' |       \
          sed -e 's,\\n,\n,g' -e 's,\\/,\\,g' -e 's,//,/,g')"
endef

Un exemple d'utilisation serait quelque chose comme ceci:

define TEST
printf '>\n%s\n' "Hello
World\n/$$$$/"
endef

all:
        $(call oneshell,$(TEST))

Cela montre la sortie (en supposant pid 27801):

>
Hello
World\n/27801/

Cette approche permet certaines fonctionnalités supplémentaires:

define oneshell
@eval "set -eux ; $$(printf '%s\n' '$(strip                            \
                                    $(subst $(_oneshell_newline_),\n,  \
                                    $(subst \,\/,                      \
                                    $(subst /,//,                      \
                                    $(subst ','"'"',$(1))))))' |       \
                     sed -e 's,\\n,\n,g' -e 's,\\/,\\,g' -e 's,//,/,g')"
endef

Ces options de shell vont:

• Imprimer chaque commande au fur et à mesure de son exécution
• Quitter à la première commande ayant échoué
• Traitez l'utilisation de variables shell non définies comme une erreur

D'autres possibilités intéressantes se suggéreront probablement.

J'aime mieux la réponse d'alhadis. Mais pour conserver le formatage en colonnes, ajoutez une dernière chose.

SYNOPSIS := :: Synopsis: Makefile\
| ::\
| :: Usage:\
| ::    make .......... : generates this message\
| ::    make synopsis . : generates this message\
| ::    make clean .... : eliminate unwanted intermediates and targets\
| ::    make all ...... : compile entire system from ground-up\
endef

Les sorties:

:: Synopsis: Makefile 
:: 
:: Usage: 
:: make .......... : generates this message 
:: make synopsis . : generates this message 
:: make clean .... : eliminate unwanted intermediates and targets 
:: make all ...... : compile entire system from ground-up

Pas complètement lié au PO, mais j'espère que cela aidera quelqu'un à l'avenir. (car cette question est celle qui revient le plus dans les recherches Google).

Dans mon Makefile, je voulais passer le contenu d'un fichier, à une commande de construction de docker, après beaucoup de consternation, j'ai décidé de:

 base64 encode the contents in the Makefile (so that I could have a single line and pass them as a docker build arg...)
 base64 decode the contents in the Dockerfile (and write them to a file)

voir l'exemple ci-dessous.

nb: Dans mon cas particulier, je voulais passer une clé ssh, lors de la construction de l'image, en utilisant l'exemple de https://vsupalov.com/build-docker-image-clone-private-repo-ssh-key/ (en utilisant une build de docker en plusieurs étapes pour cloner un repo git, puis déposez la clé ssh de l'image finale dans la 2ème étape de la construction)

Makefile

...
MY_VAR_ENCODED=$(shell cat /path/to/my/file | base64)

my-build:
    @docker build \
      --build-arg MY_VAR_ENCODED="$(MY_VAR_ENCODED)" \
      --no-cache \
      -t my-docker:build .
...

Dockerfile

...
ARG MY_VAR_ENCODED

RUN mkdir /root/.ssh/  && \
    echo "${MY_VAR_ENCODED}" | base64 -d >  /path/to/my/file/in/container
... 

Avec GNU Make 3.82 et supérieur, l' .ONESHELLoption est votre ami quand il s'agit d'extraits de shell multilignes. En rassemblant les indices d'autres réponses, j'obtiens:

VERSION = 1.2.3
PACKAGE_NAME = foo-bar
DOWNLOAD_URL = $(PACKAGE_NAME).somewhere.net

define nwln

endef

define ANNOUNCE_BODY
Version $(VERSION) of $(PACKAGE_NAME) has been released.

It can be downloaded from $(DOWNLOAD_URL).

etc, etc.
endef

.ONESHELL:

# mind the *leading* <tab> character
version:
    @printf "$(subst $(nwln),\n,$(ANNOUNCE_BODY))"

Assurez-vous, lorsque vous copiez et collez l'exemple ci-dessus dans votre éditeur, que tous les <tab>caractères sont conservés, sinon la versioncible se cassera!

Notez que .ONESHELLtoutes les cibles du Makefile utiliseront un seul shell pour toutes leurs commandes.

Pas vraiment une réponse utile, mais juste pour indiquer que `` définir '' ne fonctionne pas comme la réponse d'Axe (ne rentre pas dans un commentaire):

VERSION=4.3.1
PACKAGE_NAME=foobar
DOWNLOAD_URL=www.foobar.com

define ANNOUNCE_BODY
    Version $(VERSION) of $(PACKAGE_NAME) has been released
    It can be downloaded from $(DOWNLOAD_URL)
    etc, etc
endef

all:
    @echo $(ANNOUNCE_BODY)

Cela donne une erreur indiquant que la commande «Il» ne peut pas être trouvée, donc il essaie d'interpréter la deuxième ligne de ANNOUNCE BODY comme une commande.

Cela a fonctionné pour moi:

ANNOUNCE_BODY="first line\\nsecond line"

all:
    @echo -e $(ANNOUNCE_BODY)

GNU Makefile peut faire des choses comme ce qui suit. C'est moche, et je ne dirai pas que vous devriez le faire, mais je le fais dans certaines situations.

PROFILE = \
\#!/bin/sh.exe\n\
\#\n\
\# A MinGW equivalent for .bash_profile on Linux.  In MinGW/MSYS, the file\n\
\# is actually named .profile, not .bash_profile.\n\
\#\n\
\# Get the aliases and functions\n\
\#\n\
if [ -f \$${HOME}/.bashrc ]\n\
then\n\
  . \$${HOME}/.bashrc\n\
fi\n\
\n\
export CVS_RSH="ssh"\n  
#
.profile:
        echo -e "$(PROFILE)" | sed -e 's/^[ ]//' >.profile

make .profile crée un fichier .profile s'il n'en existe pas.

Cette solution a été utilisée là où l'application utilisera uniquement GNU Makefile dans un environnement shell POSIX. Le projet n'est pas un projet open source où la compatibilité des plates-formes est un problème.

L'objectif était de créer un Makefile qui facilite à la fois la configuration et l'utilisation d'un type particulier d'espace de travail. Le Makefile apporte avec lui diverses ressources simples sans nécessiter des choses comme une autre archive spéciale, etc. C'est, en un sens, une archive shell. Une procédure peut alors dire des choses comme déposer ce Makefile dans le dossier pour travailler. Configurez votre espace de travail enter make workspace, puis pour faire bla, enter make blah, etc.

Ce qui peut être délicat, c'est de savoir quoi faire. Ce qui précède fait le travail et est proche de l'idée de spécifier un document ici dans le Makefile. Que ce soit une bonne idée pour une utilisation générale est une toute autre question.

Je pense que la réponse la plus sûre pour une utilisation multiplateforme serait d'utiliser un écho par ligne:

  ANNOUNCE.txt:
    rm -f $@
    echo "Version $(VERSION) of $(PACKAGE_NAME) has been released" > $@
    echo "" >> $@
    echo "It can be downloaded from $(DOWNLOAD_URL)" >> $@
    echo >> $@
    echo etc, etc" >> $@

Cela évite de faire des hypothèses sur la version de l'écho disponible.

Utilisez la substitution de chaîne :

VERSION := 1.1.1
PACKAGE_NAME := Foo Bar
DOWNLOAD_URL := https://go.get/some/thing.tar.gz

ANNOUNCE_BODY := Version $(VERSION) of $(PACKAGE_NAME) has been released. \
    | \
    | It can be downloaded from $(DOWNLOAD_URL) \
    | \
    | etc, etc

Puis dans votre recette, mettez

    @echo $(subst | ,$$'\n',$(ANNOUNCE_BODY))

Cela fonctionne car Make remplace toutes les occurrences de | (notez l'espace) et le remplace par un caractère de nouvelle ligne ( $$'\n'). Vous pouvez penser aux invocations équivalentes de script shell comme étant quelque chose comme ceci:

Avant:

$ echo "Version 1.1.1 of Foo Bar has been released. | | It can be downloaded from https://go.get/some/thing.tar.gz | | etc, etc"

Après:

$ echo "Version 1.1.1 of Foo Bar has been released.
>
> It can be downloaded from https://go.get/some/thing.tar.gz
> 
> etc, etc"

Je ne sais pas si $'\n'est disponible sur les systèmes non POSIX, mais si vous pouvez accéder à un seul caractère de nouvelle ligne (même en lisant une chaîne à partir d'un fichier externe), le principe sous-jacent est le même.

Si vous avez beaucoup de messages comme celui-ci, vous pouvez réduire le bruit en utilisant une macro :

print = $(subst | ,$$'\n',$(1))

Où vous l'invoqueriez comme ceci:

@$(call print,$(ANNOUNCE_BODY))

J'espère que cela aide quelqu'un. =)

Vous pouvez également utiliser la commande printf. Ceci est utile sur OSX ou d'autres plates-formes avec moins de fonctionnalités.

Pour sortir simplement un message multiligne:

all:
        @printf '%s\n' \
            'Version $(VERSION) has been released' \
            '' \
            'You can download from URL $(URL)'

Si vous essayez de transmettre la chaîne comme argument à un autre programme, vous pouvez le faire comme ceci:

all:
        /some/command "`printf '%s\n' 'Version $(VERSION) has been released' '' 'You can download from URL $(URL)'`"