J'ai plusieurs Makefiles dans des répertoires spécifiques à l'application comme celui-ci:

/project1/apps/app_typeA/Makefile
/project1/apps/app_typeB/Makefile
/project1/apps/app_typeC/Makefile

Chaque Makefile inclut un fichier .inc dans ce chemin d'un niveau supérieur:

/project1/apps/app_rules.inc

Dans app_rules.inc, je définis la destination de l'endroit où je veux que les binaires soient placés lors de la construction. Je veux que tous les binaires soient dans leur app_typechemin respectif :

/project1/bin/app_typeA/

J'ai essayé d'utiliser$(CURDIR) , comme ceci:

OUTPUT_PATH = /project1/bin/$(CURDIR)

mais à la place, j'ai fait enterrer les binaires dans le nom du chemin entier comme ceci: (remarquez la redondance)

/project1/bin/projects/users/bob/project1/apps/app_typeA

Que puis-je faire pour obtenir le "répertoire courant" d'exécution afin que je puisse connaître juste le app_typeXafin de mettre les binaires dans leur dossier de types respectifs?

La fonction shell.

Vous pouvez utiliser la shellfonction: current_dir = $(shell pwd). Ou shellen combinaison avec notdir, si vous ne devez pas le chemin absolu: current_dir = $(notdir $(shell pwd)).

Mettre à jour.

La solution donnée ne fonctionne que lorsque vous exécutez à makepartir du répertoire actuel du Makefile.
Comme l'a noté @Flimm:

Notez que cela retourne le répertoire de travail actuel, pas le répertoire parent du Makefile.
Par exemple, si vous exécutez cd /; make -f /home/username/project/Makefile, la current_dirvariable sera /, non /home/username/project/.

Le code ci-dessous fonctionnera pour les Makefiles invoqués depuis n'importe quel répertoire:

mkfile_path := $(abspath $(lastword $(MAKEFILE_LIST)))
current_dir := $(notdir $(patsubst %/,%,$(dir $(mkfile_path))))

Tiré d' ici ;

ROOT_DIR:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))

Apparaît comme;

$ cd /home/user/

$ make -f test/Makefile 
/home/user/test

$ cd test; make Makefile 
/home/user/test

J'espère que cela t'aides

Si vous utilisez GNU make, $ (CURDIR) est en fait une variable intégrée. C'est l' emplacement où le Makefile réside dans le répertoire de travail actuel, qui est probablement où se trouve le Makefile, mais pas toujours .

OUTPUT_PATH = /project1/bin/$(notdir $(CURDIR))

Voir l'annexe A Référence rapide sur http://www.gnu.org/software/make/manual/make.html

THIS_DIR := $(dir $(abspath $(firstword $(MAKEFILE_LIST))))

J'ai essayé plusieurs de ces réponses, mais sur mon système AIX avec GNU make 3.80, je devais faire certaines choses à l'ancienne.

Il s'avère que lastword, abspathet realpathn'ont pas été ajoutés avant 3,81. :(

mkfile_path := $(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST))
mkfile_dir:=$(shell cd $(shell dirname $(mkfile_path)); pwd)
current_dir:=$(notdir $(mkfile_dir))

Comme d'autres l'ont dit, pas le plus élégant car il invoque deux fois un shell, et il a toujours des problèmes d'espace.

Mais comme je n'ai pas d'espace sur mes chemins, cela fonctionne pour moi quelle que soit la façon dont j'ai commencé make:

• make -f ../wherever/makefile
• faire -C ../partout
• faire -C ~ / partout
• cd ../wherever; faire

Tous me donnent whereverpour current_diret le chemin absolu vers whereverpour mkfile_dir.

J'aime la réponse choisie, mais je pense qu'il serait plus utile de la montrer réellement que de l'expliquer.

/tmp/makefile_path_test.sh

#!/bin/bash -eu

# Create a testing dir
temp_dir=/tmp/makefile_path_test
proj_dir=$temp_dir/dir1/dir2/dir3
mkdir -p $proj_dir

# Create the Makefile in $proj_dir
# (Because of this, $proj_dir is what $(path) should evaluate to.)
cat > $proj_dir/Makefile <<'EOF'
path := $(patsubst %/,%,$(dir $(abspath $(lastword $(MAKEFILE_LIST)))))
cwd  := $(shell pwd)

all:
    @echo "MAKEFILE_LIST: $(MAKEFILE_LIST)"
    @echo "         path: $(path)"
    @echo "          cwd: $(cwd)"
    @echo ""
EOF

# See/debug each command
set -x

# Test using the Makefile in the current directory
cd $proj_dir
make

# Test passing a Makefile
cd $temp_dir
make -f $proj_dir/Makefile

# Cleanup
rm -rf $temp_dir

Production:

+ cd /tmp/makefile_path_test/dir1/dir2/dir3
+ make
MAKEFILE_LIST:  Makefile
         path: /private/tmp/makefile_path_test/dir1/dir2/dir3
          cwd: /tmp/makefile_path_test/dir1/dir2/dir3

+ cd /tmp/makefile_path_test
+ make -f /tmp/makefile_path_test/dir1/dir2/dir3/Makefile
MAKEFILE_LIST:  /tmp/makefile_path_test/dir1/dir2/dir3/Makefile
         path: /tmp/makefile_path_test/dir1/dir2/dir3
          cwd: /tmp/makefile_path_test

+ rm -rf /tmp/makefile_path_test

REMARQUE: la fonction $(patsubst %/,%,[path/goes/here/])est utilisée pour supprimer la barre oblique de fin.

Solution trouvée ici: https://sourceforge.net/p/ipt-netflow/bugs-requests-patches/53/

La solution est : $ (CURDIR)

Vous pouvez l'utiliser comme ça:

CUR_DIR = $(CURDIR)

## Start :
start:
    cd $(CUR_DIR)/path_to_folder

Voici une ligne pour obtenir le chemin absolu vers votre Makefilefichier en utilisant la syntaxe shell:

SHELL := /bin/bash
CWD := $(shell cd -P -- '$(shell dirname -- "$0")' && pwd -P)

Et voici la version sans shell basée sur la réponse @ 0xff :

CWD := $(abspath $(patsubst %/,%,$(dir $(abspath $(lastword $(MAKEFILE_LIST))))))

Testez-le en l'imprimant, comme:

cwd:
        @echo $(CWD)

Pour autant que je sache, c'est la seule réponse ici qui fonctionne correctement avec les espaces:

space:= 
space+=

CURRENT_PATH := $(subst $(lastword $(notdir $(MAKEFILE_LIST))),,$(subst $(space),\$(space),$(shell realpath '$(strip $(MAKEFILE_LIST))')))

Il fonctionne essentiellement en échappant les caractères d'espace en les remplaçant ' 'par '\ 'ce qui permet à Make de l'analyser correctement, puis il supprime le nom de fichier du makefile en MAKEFILE_LISTfaisant une autre substitution de sorte que vous vous retrouvez avec le répertoire dans lequel se trouve makefile. Pas exactement le plus compact chose dans le monde, mais cela fonctionne.

Vous vous retrouverez avec quelque chose comme ça où tous les espaces sont échappés:

$(info CURRENT_PATH = $(CURRENT_PATH))

CURRENT_PATH = /mnt/c/Users/foobar/gDrive/P\ roje\ cts/we\ b/sitecompiler/

Exemple pour votre référence, comme ci-dessous:

La structure des dossiers peut être la suivante:

Où il y a deux Makefiles, chacun comme ci-dessous;

sample/Makefile
test/Makefile

Voyons maintenant le contenu des Makefiles.

échantillon / Makefile

export ROOT_DIR=${PWD}

all:
    echo ${ROOT_DIR}
    $(MAKE) -C test

test / Makefile

all:
    echo ${ROOT_DIR}
    echo "make test ends here !"

Maintenant, exécutez l'exemple / Makefile, en tant que;

cd sample
make

PRODUCTION:

echo /home/symphony/sample
/home/symphony/sample
make -C test
make[1]: Entering directory `/home/symphony/sample/test'
echo /home/symphony/sample
/home/symphony/sample
echo "make test ends here !"
make test ends here !
make[1]: Leaving directory `/home/symphony/sample/test'

L'explication serait que le répertoire parent / home peut être stocké dans l'indicateur d'environnement, et peut être exporté, afin qu'il puisse être utilisé dans tous les makefiles du sous-répertoire.

update 2018/03/05 finnaly j'utilise ceci:

shellPath=`echo $PWD/``echo ${0%/*}`

# process absolute path
shellPath1=`echo $PWD/`
shellPath2=`echo ${0%/*}`
if [ ${shellPath2:0:1} == '/' ] ; then
    shellPath=${shellPath2}
fi

Il peut être exécuté correctement dans un chemin relatif ou un chemin absolu. Exécuté correctement appelé par crontab. Exécuté correctement dans un autre shell.

montrer l'exemple, a .sh print self path.

[root@izbp1a7wyzv7b5hitowq2yz /]# more /root/test/a.sh
shellPath=`echo $PWD/``echo ${0%/*}`

# process absolute path
shellPath1=`echo $PWD/`
shellPath2=`echo ${0%/*}`
if [ ${shellPath2:0:1} == '/' ] ; then
    shellPath=${shellPath2}
fi

echo $shellPath
[root@izbp1a7wyzv7b5hitowq2yz /]# more /root/b.sh
shellPath=`echo $PWD/``echo ${0%/*}`

# process absolute path
shellPath1=`echo $PWD/`
shellPath2=`echo ${0%/*}`
if [ ${shellPath2:0:1} == '/' ] ; then
    shellPath=${shellPath2}
fi

$shellPath/test/a.sh
[root@izbp1a7wyzv7b5hitowq2yz /]# ~/b.sh
/root/test
[root@izbp1a7wyzv7b5hitowq2yz /]# /root/b.sh
/root/test
[root@izbp1a7wyzv7b5hitowq2yz /]# cd ~
[root@izbp1a7wyzv7b5hitowq2yz ~]# ./b.sh
/root/./test
[root@izbp1a7wyzv7b5hitowq2yz ~]# test/a.sh
/root/test
[root@izbp1a7wyzv7b5hitowq2yz ~]# cd test
[root@izbp1a7wyzv7b5hitowq2yz test]# ./a.sh
/root/test/.
[root@izbp1a7wyzv7b5hitowq2yz test]# cd /
[root@izbp1a7wyzv7b5hitowq2yz /]# /root/test/a.sh
/root/test
[root@izbp1a7wyzv7b5hitowq2yz /]# 

vieux: j'utilise ceci:

MAKEFILE_PATH := $(PWD)/$({0%/*})

Il peut s'afficher correctement s'il est exécuté dans un autre shell et un autre répertoire.

Une ligne dans le Makefile devrait suffire:

DIR := $(notdir $(CURDIR))