Makefile'da çok satırlı bir dize değişkeni oluşturmak mümkün mü

Çok satırlı bir dize olan bir makefile değişkeni oluşturmak istiyorum (örneğin, bir e-posta yayın duyurusunun gövdesi). gibi bir şey

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

It can be downloaded from $(DOWNLOAD_URL)

etc, etc"

Ama bunu yapmanın bir yolunu bulamıyorum. Mümkün mü?

Evet, çok satırlı bir değişken bildirmek için define anahtar sözcüğünü şu şekilde kullanabilirsiniz:

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

It can be downloaded from $(DOWNLOAD_URL).

etc, etc.
endef

İşin zor kısmı, çok satırlı değişkeninizi makefile'dan geri almaktır. Eğer "echo $ (ANNOUNCE_BODY)" kullanarak apaçık olan şeyi yaparsanız, diğerlerinin buraya gönderdiği sonucu görürsünüz - kabuk değişkenin ikinci ve sonraki satırlarını komut olarak kendileri işlemeye çalışır.

Bununla birlikte, değişken değerini olduğu gibi kabuğa bir ortam değişkeni olarak dışa aktarabilir ve ardından onu bir ortam değişkeni olarak kabuktan referans alabilirsiniz (bir make değişkeni DEĞİL). Örneğin:

export ANNOUNCE_BODY
all:
    @echo "$$ANNOUNCE_BODY"

Normal bir make değişken referansı $$ANNOUNCE_BODYyerine, bir kabuk ortam değişkeni referansını belirten kullanımına dikkat edin $(ANNOUNCE_BODY). Ayrıca, yeni satırların kabuğun kendisi tarafından yorumlanmadığından emin olmak için değişken referansınızın etrafında tırnak işaretleri kullandığınızdan emin olun.

Tabii ki, bu özel numara platforma ve kabuğa duyarlı olabilir. Ubuntu Linux üzerinde GNU bash 3.2.13 ile test ettim; YMMV.

'Çok satırlı değişkeninizi makefile'dan çıkarmak' için başka bir yaklaşım (Eric Melski tarafından 'zor kısım' olarak belirtilmiştir), substişlevi defineçok satırlı dizenizde bulunan satırsonlarını değiştirmek için kullanmayı planlamaktır \n. Sonra echobunları yorumlamak için -e ile birlikte kullanın. Bunu yapan bir yankı elde etmek için .SHELL = bash ayarlamanız gerekebilir.

Bu yaklaşımın bir avantajı, bu tür diğer kaçış karakterlerini de metninize koymanız ve bunlara saygı duymanızdır.

Bu tür şu ana kadar bahsedilen tüm yaklaşımları sentezler ...

Şunlarla doluyorsunuz:

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})'

Son ekodaki tek alıntıların çok önemli olduğuna dikkat edin.

Değişkeninizin içeriğini yalnızca standart çıktıya yazdırmak istediğinizi varsayarsak, başka bir çözüm vardır:

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

Evet. Yeni satırlardan şu şekilde kaçarsınız \:

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

Güncelleme

Ah, yeni satırları mı istiyorsun? O halde hayır, vanilya yapımında herhangi bir yol olduğunu sanmıyorum. Ancak, komut bölümünde her zaman bir buradaki belgeyi kullanabilirsiniz.

[Bu işe yaramıyor, MadScientist'in yorumuna bakın]

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

Eric Melski'nin cevabına bir ek: Metne komutların çıktısını dahil edebilirsiniz, ancak "$ (foo)" kabuk sözdizimi yerine Makefile sözdizimi "$ (shell foo)" kullanmalısınız. Örneğin:

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

It can be downloaded from $(DOWNLOAD_URL).  

endef

"Define / endef" Make yapısını kullanmalısınız:

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

It can be downloaded from $(DOWNLOAD_URL).

etc, etc.
endef

Daha sonra bu değişkenin değerini kabuk komutuna iletmelisiniz. Ancak, bunu Make değişken ikamesi kullanarak yaparsanız, komutun birden çok parçaya bölünmesine neden olur:

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

Sorgulamak da yardımcı olmayacak.

Değeri iletmenin en iyi yolu, onu ortam değişkeni aracılığıyla iletmektir:

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

Farkına varmak:

1. Değişken, bu belirli hedef için dışa aktarılır, böylece bu ortamı yeniden kullanabilirsiniz, çok fazla kirlenmez;
2. Ortam değişkeni kullanın (değişken adının etrafında çift satır ve küme parantezleri);
3. Değişken etrafında alıntıların kullanılması. Bunlar olmadan yeni satırlar kaybolacak ve tüm metin tek satırda görünecektir.

Bu, burada bir belge vermez, ancak borulara uygun bir şekilde çok satırlı bir mesaj görüntüler.

=====

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

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

=====

Ayrıca Gnu'nun çağrılabilir makrolarını da kullanabilirsiniz:

=====

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 "---"

=====

İşte çıktı:

=====

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

=====

Satır sonunu tanımlamak için neden dizenizde \ n karakterini kullanmıyorsunuz? Ayrıca, birden çok satıra eklemek için fazladan ters eğik çizgiyi ekleyin.

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

GNU "make 'manual, 6.8: Çok Satırlı Değişkenleri Tanımlama

.ONESHELL ruhu içinde, .ONESHELL'in zorlu ortamlarında oldukça yakınlaşmak mümkündür:

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

Kullanım örneği şunun gibi bir şey olabilir:

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

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

Bu çıktıyı gösterir (pid 27801 varsayılarak):

>
Hello
World\n/27801/

Bu yaklaşım, bazı ekstra işlevlere izin verir:

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

Bu kabuk seçenekleri:

• Her komutu yürütülürken yazdırın
• İlk başarısız komuttan çıkın
• Tanımlanmamış kabuk değişkenlerinin kullanımını bir hata olarak ele alın

Diğer ilginç olasılıklar muhtemelen kendilerini gösterecektir.

Alhadis'in cevabını en çok seviyorum. Ancak sütunlu biçimlendirmeyi korumak için bir şey daha ekleyin.

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

Çıktılar:

:: 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

Tamamen OP ile ilgili değil, ancak umarım bu gelecekte birine yardımcı olur. (çünkü bu soru google aramalarında en çok karşımıza çıkan sorudur).

Makefile dosyamda, bir dosyanın içeriğini bir docker build komutuna geçirmek istedim, çok fazla şaşkınlıktan sonra, karar verdim:

 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)

aşağıdaki örneğe bakın.

nb: Benim özel durumumda, görüntü oluşturma sırasında https://vsupalov.com/build-docker-image-clone-private-repo-ssh-key/ (kullanarak bir git deposunu klonlamak için çok aşamalı bir docker derlemesi, ardından yapının 2. aşamasındaki son görüntüden ssh anahtarını bırakın)

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
... 

GNU Make 3.82 ve üstü ile, konu .ONESHELLçok satırlı kabuk parçacıkları olduğunda arkadaşınızdır. Diğer cevaplardan ipuçlarını bir araya getirerek şunu anlıyorum:

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))"

Yukarıdaki örneği düzenleyicinize kopyalayıp yapıştırırken, tüm <tab>karakterlerin korunduğundan emin olun, aksi takdirde versionhedef kırılır!

.ONESHELLBunun Makefile'daki tüm hedeflerin tüm komutları için tek bir kabuk kullanmasına neden olacağını unutmayın .

Gerçekten yararlı bir cevap değil, ama sadece 'tanımla'nın Ax tarafından cevaplandığı gibi çalışmadığını belirtmek için (bir yoruma uymadı):

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)

'O' komutunun bulunamaması hatası veriyor, bu nedenle ANNOUNCE BODY'nin ikinci satırını bir komut olarak yorumlamaya çalışıyor.

Benim için çalıştı:

ANNOUNCE_BODY="first line\\nsecond line"

all:
    @echo -e $(ANNOUNCE_BODY)

GNU Makefile aşağıdaki gibi şeyler yapabilir. Çirkin ve yapman gerektiğini söylemeyeceğim, ama bazı durumlarda yaparım.

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 yoksa bir .profile dosyası oluşturur.

Bu çözüm, uygulamanın bir POSIX kabuk ortamında yalnızca GNU Makefile'ı kullanacağı durumlarda kullanıldı. Proje, platform uyumluluğunun sorun olduğu açık kaynaklı bir proje değildir.

Amaç, belirli bir çalışma alanının hem kurulumunu hem de kullanımını kolaylaştıran bir Makefile oluşturmaktı. Makefile, başka bir özel arşiv vb. Gibi şeyler gerektirmeden çeşitli basit kaynakları da beraberinde getiriyor. Bu bir anlamda bir kabuk arşividir. Bir prosedür daha sonra bu Makefile'ı çalışmak için klasöre bırakmak gibi şeyler söyleyebilir. Çalışma alanınızı girin enter make workspace, ardından blah, enter make blahvb. Yapmak için ayarlayın .

Zorlaşan şey, neyin alınacağını bulmaktır. Yukarıdakiler işi yapar ve Makefile'da bir burada belge belirtme fikrine yakındır. Genel kullanım için iyi bir fikir olup olmadığı tamamen başka bir konudur.

Çapraz platform kullanımı için en güvenli cevabın her satırda bir yankı kullanmak olduğuna inanıyorum:

  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" >> $@

Bu, mevcut yankı sürümüyle ilgili herhangi bir varsayımda bulunmaktan kaçınır.

Dize ikamesi kullanın :

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

Sonra tarifinize koyun

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

Bu işe yarar çünkü Make tüm tekrarlarını değiştirir | (boşluğa dikkat edin) ve onu bir satırsonu karakteri ( $$'\n') ile değiştirir. Eşdeğer kabuk betiği çağrılarını şunun gibi düşünebilirsiniz:

Önce:

$ 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"

Sonra:

$ 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"

$'\n'POSIX olmayan sistemlerde mevcut olup olmadığından emin değilim , ancak tek bir satırsonu karakterine erişebilirseniz (harici bir dosyadan bir dizeyi okuyarak bile), temel ilke aynıdır.

Bunun gibi birçok mesajınız varsa, bir makro kullanarak gürültüyü azaltabilirsiniz :

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

Bunu böyle çağırırdın:

@$(call print,$(ANNOUNCE_BODY))

Umarım bu birine yardımcı olur. =)

Alternatif olarak printf komutunu kullanabilirsiniz. Bu, OSX veya daha az özelliğe sahip diğer platformlarda yararlıdır.

Çok satırlı bir mesajın çıktısını almak için:

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

Dizeyi başka bir programa argüman olarak iletmeye çalışıyorsanız, bunu şu şekilde yapabilirsiniz:

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