OS détectant le makefile

Je travaille régulièrement sur plusieurs ordinateurs différents et plusieurs systèmes d'exploitation différents, qui sont Mac OS X, Linux ou Solaris. Pour le projet sur lequel je travaille, je tire mon code d'un dépôt git distant.

J'aime pouvoir travailler sur mes projets quel que soit le terminal où je suis. Jusqu'à présent, j'ai trouvé des moyens de contourner les modifications du système d'exploitation en changeant le makefile chaque fois que je change d'ordinateurs. Cependant, cela est fastidieux et provoque un tas de maux de tête.

Comment puis-je modifier mon makefile afin qu'il détecte le système d'exploitation que j'utilise et modifie la syntaxe en conséquence?

Voici le makefile:

cc = gcc -g
CC = g++ -g
yacc=$(YACC)
lex=$(FLEX)

all: assembler

assembler: y.tab.o lex.yy.o
        $(CC) -o assembler y.tab.o lex.yy.o -ll -l y

assembler.o: assembler.c
        $(cc) -o assembler.o assembler.c

y.tab.o: assem.y
        $(yacc) -d assem.y
        $(CC) -c y.tab.c

lex.yy.o: assem.l
        $(lex) assem.l
        $(cc) -c lex.yy.c

clean:
        rm -f lex.yy.c y.tab.c y.tab.h assembler *.o *.tmp *.debug *.acts

Il y a déjà beaucoup de bonnes réponses ici, mais je voulais partager un exemple plus complet que les deux:

• ne suppose pas qu'il unameexiste sous Windows
• détecte également le processeur

Les CCFLAGS définis ici ne sont pas nécessairement recommandés ou idéaux; ils sont exactement ce que le projet auquel j'ajoutais la détection automatique OS / CPU était en train d'utiliser.

ifeq ($(OS),Windows_NT)
    CCFLAGS += -D WIN32
    ifeq ($(PROCESSOR_ARCHITEW6432),AMD64)
        CCFLAGS += -D AMD64
    else
        ifeq ($(PROCESSOR_ARCHITECTURE),AMD64)
            CCFLAGS += -D AMD64
        endif
        ifeq ($(PROCESSOR_ARCHITECTURE),x86)
            CCFLAGS += -D IA32
        endif
    endif
else
    UNAME_S := $(shell uname -s)
    ifeq ($(UNAME_S),Linux)
        CCFLAGS += -D LINUX
    endif
    ifeq ($(UNAME_S),Darwin)
        CCFLAGS += -D OSX
    endif
    UNAME_P := $(shell uname -p)
    ifeq ($(UNAME_P),x86_64)
        CCFLAGS += -D AMD64
    endif
    ifneq ($(filter %86,$(UNAME_P)),)
        CCFLAGS += -D IA32
    endif
    ifneq ($(filter arm%,$(UNAME_P)),)
        CCFLAGS += -D ARM
    endif
endif

La commande uname ( http://developer.apple.com/documentation/Darwin/Reference/ManPages/man1/uname.1.html ) sans paramètres devrait vous indiquer le nom du système d'exploitation. Je l'utiliserais, puis ferais des conditions en fonction de la valeur de retour.

Exemple

UNAME := $(shell uname)

ifeq ($(UNAME), Linux)
# do something Linux-y
endif
ifeq ($(UNAME), Solaris)
# do something Solaris-y
endif

Détectez le système d'exploitation à l'aide de deux astuces simples:

• D'abord la variable d'environnement OS
• Ensuite, la unamecommande

ifeq ($(OS),Windows_NT)     # is Windows_NT on XP, 2000, 7, Vista, 10...
    detected_OS := Windows
else
    detected_OS := $(shell uname)  # same as "uname -s"
endif

Ou un moyen plus sûr, sinon sous Windows et unameindisponible:

ifeq ($(OS),Windows_NT) 
    detected_OS := Windows
else
    detected_OS := $(shell sh -c 'uname 2>/dev/null || echo Unknown')
endif

Ken Jackson propose une alternative intéressante si vous souhaitez distinguer Cygwin / MinGW / MSYS / Windows. Voir sa réponse qui ressemble à ça:

ifeq '$(findstring ;,$(PATH))' ';'
    detected_OS := Windows
else
    detected_OS := $(shell uname 2>/dev/null || echo Unknown)
    detected_OS := $(patsubst CYGWIN%,Cygwin,$(detected_OS))
    detected_OS := $(patsubst MSYS%,MSYS,$(detected_OS))
    detected_OS := $(patsubst MINGW%,MSYS,$(detected_OS))
endif

Ensuite, vous pouvez sélectionner les éléments pertinents en fonction de detected_OS:

ifeq ($(detected_OS),Windows)
    CFLAGS += -D WIN32
endif
ifeq ($(detected_OS),Darwin)        # Mac OS X
    CFLAGS += -D OSX
endif
ifeq ($(detected_OS),Linux)
    CFLAGS   +=   -D LINUX
endif
ifeq ($(detected_OS),GNU)           # Debian GNU Hurd
    CFLAGS   +=   -D GNU_HURD
endif
ifeq ($(detected_OS),GNU/kFreeBSD)  # Debian kFreeBSD
    CFLAGS   +=   -D GNU_kFreeBSD
endif
ifeq ($(detected_OS),FreeBSD)
    CFLAGS   +=   -D FreeBSD
endif
ifeq ($(detected_OS),NetBSD)
    CFLAGS   +=   -D NetBSD
endif
ifeq ($(detected_OS),DragonFly)
    CFLAGS   +=   -D DragonFly
endif
ifeq ($(detected_OS),Haiku)
    CFLAGS   +=   -D Haiku
endif

Remarques:

• La commande unameest la même que uname -sparce que l'option -s( --kernel-name) est la valeur par défaut. Voyez pourquoi uname -sc'est mieux queuname -o .

• L'utilisation de OS(au lieu de uname) simplifie l'algorithme d'identification. Vous pouvez toujours utiliser uniquement uname, mais vous devez gérer les if/elseblocs pour vérifier toutes les variations de MinGW, Cygwin, etc.

• La variable d'environnement OSest toujours définie "Windows_NT"sur différentes versions de Windows (voir %OS%variable d'environnement sur Wikipedia ).

• Une alternative à OSest la variable d'environnement MSVC(elle vérifie la présence de MS Visual Studio , voir l' exemple utilisant Visual C ++ ).

Ci-dessous, je fournis un exemple complet en utilisant makeet gccpour construire une bibliothèque partagée: *.soou en *.dllfonction de la plateforme. L'exemple est aussi simple que possible pour être plus compréhensible.

Pour installer makeet gccsur Windows, voir Cygwin ou MinGW .

Mon exemple est basé sur cinq fichiers

 ├── lib
 │   └── Makefile
 │   └── hello.h
 │   └── hello.c
 └── app
     └── Makefile
     └── main.c

Rappel: Makefile est mis en retrait à l'aide de la tabulation . Attention lors du copier-coller sous les exemples de fichiers.

Les deux Makefilefichiers

1. lib/Makefile

ifeq ($(OS),Windows_NT)
    uname_S := Windows
else
    uname_S := $(shell uname -s)
endif

ifeq ($(uname_S), Windows)
    target = hello.dll
endif
ifeq ($(uname_S), Linux)
    target = libhello.so
endif
#ifeq ($(uname_S), .....) #See https://stackoverflow.com/a/27776822/938111
#    target = .....
#endif

%.o: %.c
    gcc  -c $<  -fPIC  -o $@
    # -c $<  => $< is first file after ':' => Compile hello.c
    # -fPIC  => Position-Independent Code (required for shared lib)
    # -o $@  => $@ is the target => Output file (-o) is hello.o

$(target): hello.o
    gcc  $^  -shared  -o $@
    # $^      => $^ expand to all prerequisites (after ':') => hello.o
    # -shared => Generate shared library
    # -o $@   => Output file (-o) is $@ (libhello.so or hello.dll)

2. app/Makefile

ifeq ($(OS),Windows_NT)
    uname_S := Windows
else
    uname_S := $(shell uname -s)
endif

ifeq ($(uname_S), Windows)
    target = app.exe
endif
ifeq ($(uname_S), Linux)
    target = app
endif
#ifeq ($(uname_S), .....) #See https://stackoverflow.com/a/27776822/938111
#    target = .....
#endif

%.o: %.c
    gcc  -c $< -I ../lib  -o $@
    # -c $<     => compile (-c) $< (first file after :) = main.c
    # -I ../lib => search headers (*.h) in directory ../lib
    # -o $@     => output file (-o) is $@ (target) = main.o

$(target): main.o
    gcc  $^  -L../lib  -lhello  -o $@
    # $^       => $^ (all files after the :) = main.o (here only one file)
    # -L../lib => look for libraries in directory ../lib
    # -lhello  => use shared library hello (libhello.so or hello.dll)
    # -o $@    => output file (-o) is $@ (target) = "app.exe" or "app"

Pour en savoir plus, lisez la documentation sur les variables automatiques comme indiqué par cfi .

Le code source

- lib/hello.h

#ifndef HELLO_H_
#define HELLO_H_

const char* hello();

#endif

- lib/hello.c

#include "hello.h"

const char* hello()
{
    return "hello";
}

- app/main.c

#include "hello.h" //hello()
#include <stdio.h> //puts()

int main()
{
    const char* str = hello();
    puts(str);
}

La construction

Corrigez le copier-coller de Makefile(remplacez les espaces de tête par une tabulation).

> sed  's/^  */\t/'  -i  */Makefile

La makecommande est la même sur les deux plateformes. La sortie donnée est sur des OS de type Unix:

> make -C lib
make: Entering directory '/tmp/lib'
gcc  -c hello.c  -fPIC  -o hello.o
# -c hello.c  => hello.c is first file after ':' => Compile hello.c
# -fPIC       => Position-Independent Code (required for shared lib)
# -o hello.o  => hello.o is the target => Output file (-o) is hello.o
gcc  hello.o  -shared  -o libhello.so
# hello.o        => hello.o is the first after ':' => Link hello.o
# -shared        => Generate shared library
# -o libhello.so => Output file (-o) is libhello.so (libhello.so or hello.dll)
make: Leaving directory '/tmp/lib'

> make -C app
make: Entering directory '/tmp/app'
gcc  -c main.c -I ../lib  -o main.o
# -c main.c => compile (-c) main.c (first file after :) = main.cpp
# -I ../lib => search headers (*.h) in directory ../lib
# -o main.o => output file (-o) is main.o (target) = main.o
gcc  main.o  -L../lib  -lhello  -o app
# main.o   => main.o (all files after the :) = main.o (here only one file)
# -L../lib => look for libraries in directory ../lib
# -lhello  => use shared library hello (libhello.so or hello.dll)
# -o app   => output file (-o) is app.exe (target) = "app.exe" or "app"
make: Leaving directory '/tmp/app'

La course

L'application nécessite de savoir où se trouve la bibliothèque partagée.

Sous Windows, une solution simple consiste à copier la bibliothèque où se trouve l'application:

> cp -v lib/hello.dll app
`lib/hello.dll' -> `app/hello.dll'

Sur les OS de type Unix, vous pouvez utiliser la LD_LIBRARY_PATHvariable d'environnement:

> export LD_LIBRARY_PATH=lib

Exécutez la commande sous Windows:

> app/app.exe
hello

Exécutez la commande sur les systèmes d'exploitation de type Unix:

> app/app
hello

J'expérimentais récemment pour répondre à cette question que je me posais. Voici mes conclusions:

Étant donné que dans Windows, vous ne pouvez pas être sûr que la unamecommande est disponible, vous pouvez utiliser gcc -dumpmachine. Cela affichera la cible du compilateur.

Il peut également y avoir un problème lors de l'utilisation unamesi vous souhaitez effectuer une compilation croisée.

Voici un exemple de liste de sortie possible de gcc -dumpmachine:

• mingw32
• i686-pc-cygwin
• x86_64-redhat-linux

Vous pouvez vérifier le résultat dans le makefile comme ceci:

SYS := $(shell gcc -dumpmachine)
ifneq (, $(findstring linux, $(SYS)))
 # Do Linux things
else ifneq(, $(findstring mingw, $(SYS)))
 # Do MinGW things
else ifneq(, $(findstring cygwin, $(SYS)))
 # Do Cygwin things
else
 # Do things for others
endif

Cela a bien fonctionné pour moi, mais je ne suis pas sûr que ce soit un moyen fiable d'obtenir le type de système. Au moins, il est fiable à propos de MinGW et c'est tout ce dont j'ai besoin car il ne nécessite pas d'avoir la unamecommande ou le package MSYS dans Windows.

Pour résumer, unamevous donne le système sur lequel vous compilez et gcc -dumpmachinevous donne le système pour lequel vous compilez.

Le makefile git contient de nombreux exemples de gestion sans autoconf / automake, tout en fonctionnant sur une multitude de plates-formes unixy.

Mise à jour: je considère maintenant cette réponse comme obsolète. J'ai posté une nouvelle solution parfaite plus bas.

Si votre makefile s'exécute sur des fenêtres non Cygwin, unamepeut ne pas être disponible. C'est gênant, mais c'est une solution potentielle. Vous devez d'abord vérifier Cygwin pour l'exclure, car il a aussi WINDOWS dans sa PATHvariable d'environnement.

ifneq (,$(findstring /cygdrive/,$(PATH)))
    UNAME := Cygwin
else
ifneq (,$(findstring WINDOWS,$(PATH)))
    UNAME := Windows
else
    UNAME := $(shell uname -s)
endif
endif

C'est le travail que l' automake / autoconf de GNU est conçu pour résoudre. Vous voudrez peut-être les enquêter.

Alternativement, vous pouvez définir des variables d'environnement sur vos différentes plates-formes et rendre votre Makefile conditionnel par rapport à celles-ci.

J'ai finalement trouvé la solution parfaite qui résout ce problème pour moi.

ifeq '$(findstring ;,$(PATH))' ';'
    UNAME := Windows
else
    UNAME := $(shell uname 2>/dev/null || echo Unknown)
    UNAME := $(patsubst CYGWIN%,Cygwin,$(UNAME))
    UNAME := $(patsubst MSYS%,MSYS,$(UNAME))
    UNAME := $(patsubst MINGW%,MSYS,$(UNAME))
endif

La variable UNAME est définie sur Linux, Cygwin, MSYS, Windows, FreeBSD, NetBSD (ou probablement Solaris, Darwin, OpenBSD, AIX, HP-UX) ou Unknown. Il peut ensuite être comparé dans le reste du Makefile pour séparer toutes les variables et commandes sensibles au système d'exploitation.

La clé est que Windows utilise des points-virgules pour séparer les chemins dans la variable PATH tandis que tout le monde utilise des deux-points. (Il est possible de créer un répertoire Linux avec un ';' dans le nom et de l'ajouter à PATH, ce qui casserait cela, mais qui ferait une telle chose?) Cela semble être la méthode la moins risquée pour détecter Windows natif car il n'a pas besoin d'un appel shell. Le Cygwin et MSYS PATH utilisent des deux-points, donc uname est appelé pour eux.

Notez que la variable d'environnement OS peut être utilisée pour détecter Windows, mais pas pour faire la distinction entre Cygwin et Windows natif. Le test de l'écho des citations fonctionne, mais il nécessite un appel shell.

Malheureusement, Cygwin ajoute des informations de version à la sortie de uname , j'ai donc ajouté les appels «patsubst» pour le changer en «Cygwin». De plus, uname for MSYS a en fait trois sorties possibles commençant par MSYS ou MINGW, mais j'utilise aussi patsubst pour tout transformer en juste 'MSYS'.

S'il est important de distinguer les systèmes Windows natifs avec et sans uname.exe sur le chemin, cette ligne peut être utilisée à la place de l'affectation simple:

UNAME := $(shell uname 2>NUL || echo Windows)

Bien sûr, dans tous les cas, GNU make est requis, ou une autre marque qui prend en charge les fonctions utilisées.

J'ai rencontré ce problème aujourd'hui et j'en avais besoin sur Solaris alors voici une façon standard POSIX de faire (quelque chose de très proche) cela.

#Detect OS
UNAME = `uname`

# Build based on OS name
DetectOS:
    -@make $(UNAME)


# OS is Linux, use GCC
Linux: program.c
    @SHELL_VARIABLE="-D_LINUX_STUFF_HERE_"
    rm -f program
    gcc $(SHELL_VARIABLE) -o program program.c

# OS is Solaris, use c99
SunOS: program.c
    @SHELL_VARIABLE="-D_SOLARIS_STUFF_HERE_"
    rm -f program
    c99 $(SHELL_VARIABLE) -o program program.c

Voici une solution simple qui vérifie si vous êtes dans un environnement Windows ou de type posix (Linux / Unix / Cygwin / Mac):

ifeq ($(shell echo "check_quotes"),"check_quotes")
   WINDOWS := yes
else
   WINDOWS := no
endif

Il profite du fait que l'écho existe à la fois dans les environnements de type posix et Windows, et que dans Windows, le shell ne filtre pas les guillemets.

Notez que les Makefiles sont extrêmement sensibles à l'espacement. Voici un exemple de Makefile qui exécute une commande supplémentaire sur OS X et qui fonctionne sur OS X et Linux. Dans l'ensemble, cependant, autoconf / automake est la voie à suivre pour tout ce qui n'est pas trivial.

UNAME: = $ (shell uname -s)
CPP = g ++
CPPFLAGS = -pthread -ansi -Wall -Werror -pedantic -O0 -g3 -I / nexopia / include
LDFLAGS = -pthread -L / nexopia / lib -lboost_system

HEADERS = data_structures.h http_client.h load.h lock.h search.h server.h thread.h utility.h
OBJETS = http_client.o load.o lock.o search.o server.o thread.o utility.o vor.o

tous: vor

nettoyer:
    rm -f $ (OBJECTS) vor

vor: $ (OBJETS)
    $ (CPP) $ (LDFLAGS) -o vor $ (OBJETS)
ifeq ($ (UNAME), Darwin)
    # Définir l'emplacement de la bibliothèque Boost
    install_name_tool -change libboost_system.dylib /nexopia/lib/libboost_system.dylib vor
fin si

% .o:% .cpp $ (HEADERS) Makefile
    $ (CPP) $ (CPPFLAGS) -c $

Une autre façon de procéder consiste à utiliser un script "configure". Si vous en utilisez déjà un avec votre makefile, vous pouvez utiliser une combinaison de uname et sed pour faire avancer les choses. Tout d'abord, dans votre script, faites:

UNAME=uname

Ensuite, afin de mettre cela dans votre Makefile, commencez avec Makefile.in qui devrait avoir quelque chose comme

UNAME=@@UNAME@@

en elle.

Utilisez la commande sed suivante dans votre script de configuration après le UNAME=unamebit.

sed -e "s|@@UNAME@@|$UNAME|" < Makefile.in > Makefile

Maintenant, votre makefile devrait avoir UNAMEdéfini comme vous le souhaitez. Si les instructions / elif / else sont tout ce qui reste!

J'ai eu un cas où j'ai dû détecter la différence entre deux versions de Fedora, pour modifier les options de ligne de commande pour inkscape:
- dans Fedora 31, l'inkscape par défaut est 1.0beta qui utilise --export-file
- dans Fedora <31, l'inkscape par défaut est 0.92 qui utilise--export-pdf

Mon Makefile contient les éléments suivants

# set VERSION_ID from /etc/os-release

$(eval $(shell grep VERSION_ID /etc/os-release))

# select the inkscape export syntax

ifeq ($(VERSION_ID),31)
EXPORT = export-file
else
EXPORT = export-pdf
endif

# rule to convert inkscape SVG (drawing) to PDF

%.pdf : %.svg
    inkscape --export-area-drawing $< --$(EXPORT)=$@

Cela fonctionne car /etc/os-releasecontient une ligne

VERSION_ID=<value>

de sorte que la commande shell dans le Makefile renvoie la chaîne VERSION_ID=<value>, puis la commande eval agit sur cela pour définir la variable Makefile VERSION_ID. Cela peut évidemment être modifié pour d'autres systèmes d'exploitation en fonction de la façon dont les métadonnées sont stockées. Notez que dans Fedora, il n'y a pas de variable d'environnement par défaut qui donne la version du système d'exploitation, sinon j'aurais utilisé ça!