Makefile zur Erkennung des Betriebssystems

Ich arbeite routinemäßig auf mehreren verschiedenen Computern und verschiedenen Betriebssystemen, nämlich Mac OS X, Linux oder Solaris. Für das Projekt, an dem ich arbeite, ziehe ich meinen Code aus einem Remote-Git-Repository.

Ich möchte in der Lage sein, an meinen Projekten zu arbeiten, unabhängig davon, an welchem ​​Terminal ich mich befinde. Bisher habe ich Wege gefunden, um die Betriebssystemänderungen zu umgehen, indem ich das Makefile jedes Mal ändere, wenn ich den Computer wechsle. Dies ist jedoch langwierig und verursacht eine Reihe von Kopfschmerzen.

Wie kann ich mein Makefile so ändern, dass es erkennt, welches Betriebssystem ich verwende, und die Syntax entsprechend ändert?

Hier ist das 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

Hier gibt es bereits viele gute Antworten, aber ich wollte ein vollständigeres Beispiel nennen, das beide:

• geht nicht davon aus, dass unamees unter Windows existiert
• erkennt auch den Prozessor

Die hier definierten CCFLAGS sind nicht unbedingt empfohlen oder ideal. Sie sind genau das, was das Projekt, zu dem ich die automatische Erkennung von Betriebssystemen / CPUs hinzugefügt habe, zufällig verwendet hat.

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

Der Befehl uname ( http://developer.apple.com/documentation/Darwin/Reference/ManPages/man1/uname.1.html ) ohne Parameter sollte Ihnen den Namen des Betriebssystems mitteilen. Ich würde das verwenden und dann Bedingungen basierend auf dem Rückgabewert erstellen.

Beispiel

UNAME := $(shell uname)

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

Erkennen Sie das Betriebssystem mit zwei einfachen Tricks:

• Zuerst die Umgebungsvariable OS
• Dann der unameBefehl

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

Oder sicherer, wenn nicht unter Windows und unamenicht verfügbar:

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

Ken Jackson schlägt eine interessante Alternative vor, wenn Sie Cygwin / MinGW / MSYS / Windows unterscheiden möchten. Sehen Sie seine Antwort , die so aussieht:

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

Dann können Sie die relevanten Dinge auswählen, abhängig von 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

Anmerkungen:

• Der Befehl unameist der gleiche wie, uname -sda option -s( --kernel-name) die Standardeinstellung ist. Sehen Sie, warum uname -sist besser alsuname -o .

• Die Verwendung von OS(anstelle von uname) vereinfacht den Identifikationsalgorithmus. Sie können immer noch ausschließlich verwenden uname, müssen sich jedoch mit if/elseBlöcken befassen , um alle Variationen von MinGW, Cygwin usw. zu überprüfen.

• Die Umgebungsvariable OSist in "Windows_NT"verschiedenen Windows-Versionen immer auf eingestellt (siehe %OS%Umgebungsvariable auf Wikipedia ).

• Eine Alternative dazu OSist die Umgebungsvariable MSVC(sie überprüft das Vorhandensein von MS Visual Studio , siehe Beispiel mit Visual C ++ ).

Im Folgenden gebe ich ein vollständiges Beispiel für die Verwendung makeund gccErstellung einer gemeinsam genutzten Bibliothek: *.sooder *.dllje nach Plattform. Das Beispiel ist so einfach wie möglich, um verständlicher zu sein.

Informationen zur Installation makeund gccunter Windows finden Sie unter Cygwin oder MinGW .

Mein Beispiel basiert auf fünf Dateien

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

Erinnerung: Makefile wird mithilfe einer Tabelle eingerückt . Vorsicht beim Einfügen unter Beispieldateien.

Die zwei MakefileDateien

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"

Weitere Informationen finden Sie in der Dokumentation zu automatischen Variablen , auf die von cfi hingewiesen wird .

Der Quellcode

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

Der Build

Korrigieren Sie das Kopieren und Einfügen von Makefile(ersetzen Sie führende Leerzeichen durch eine Tabelle).

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

Der makeBefehl ist auf beiden Plattformen gleich. Die angegebene Ausgabe erfolgt unter Unix-ähnlichen Betriebssystemen:

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

Der Lauf

Die Anwendung muss wissen, wo sich die gemeinsam genutzte Bibliothek befindet.

Unter Windows besteht eine einfache Lösung darin, die Bibliothek zu kopieren, in der sich die Anwendung befindet:

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

Unter Unix-ähnlichen Betriebssystemen können Sie die LD_LIBRARY_PATHUmgebungsvariable verwenden:

> export LD_LIBRARY_PATH=lib

Führen Sie den Befehl unter Windows aus:

> app/app.exe
hello

Führen Sie den Befehl unter Unix-ähnlichen Betriebssystemen aus:

> app/app
hello

Ich habe kürzlich experimentiert, um diese Frage zu beantworten, die ich mir gestellt habe. Hier sind meine Schlussfolgerungen:

Da Sie in Windows nicht sicher sein können, ob der unameBefehl verfügbar ist, können Sie ihn verwenden gcc -dumpmachine. Dadurch wird das Compilerziel angezeigt.

Möglicherweise liegt auch ein Problem bei der Verwendung vor, unamewenn Sie eine Cross-Kompilierung durchführen möchten.

Hier ist eine Beispielliste möglicher Ausgaben von gcc -dumpmachine:

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

Sie können das Ergebnis im Makefile folgendermaßen überprüfen:

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

Es hat bei mir gut funktioniert, aber ich bin mir nicht sicher, ob es ein zuverlässiger Weg ist, den Systemtyp zu ermitteln. Zumindest ist MinGW zuverlässig und das ist alles, was ich brauche, da der unameBefehl oder das MSYS- Paket in Windows nicht erforderlich sind .

Zusammenfassend unamegibt es Ihnen das System, auf dem Sie kompilieren, und gcc -dumpmachinedas System für das Sie kompilieren.

Das Git-Makefile enthält zahlreiche Beispiele für die Verwaltung ohne Autoconf / Automake und funktioniert dennoch auf einer Vielzahl von Unixy-Plattformen.

Update: Ich halte diese Antwort jetzt für veraltet. Ich habe weiter unten eine neue perfekte Lösung veröffentlicht.

Wenn Ihr Makefile möglicherweise unter Nicht-Cygwin-Windows ausgeführt wird, ist es unamemöglicherweise nicht verfügbar. Das ist umständlich, aber dies ist eine mögliche Lösung. Sie müssen zuerst nach Cygwin suchen, um dies auszuschließen, da die PATHUmgebungsvariable auch WINDOWS enthält .

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

Das ist der Job, den GNUs Automake / Autoconf macht lösen soll. Vielleicht möchten Sie sie untersuchen.

Alternativ können Sie Umgebungsvariablen auf Ihren verschiedenen Plattformen festlegen und Makefile davon abhängig machen.

Ich habe endlich die perfekte Lösung gefunden, die dieses Problem für mich löst.

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

Die UNAME-Variable ist auf Linux, Cygwin, MSYS, Windows, FreeBSD, NetBSD (oder vermutlich Solaris, Darwin, OpenBSD, AIX, HP-UX) oder Unbekannt eingestellt. Es kann dann im Rest des Makefiles verglichen werden, um alle betriebssystemsensitiven Variablen und Befehle zu trennen.

Der Schlüssel ist, dass Windows Semikolons verwendet, um Pfade in der PATH-Variablen zu trennen, während alle anderen Doppelpunkte verwenden. (Es ist möglich, ein Linux-Verzeichnis mit einem ';' im Namen zu erstellen und es PATH hinzuzufügen, was dies beschädigen würde, aber wer würde so etwas tun?) Dies scheint die am wenigsten riskante Methode zu sein, um natives Windows zu erkennen, weil es benötigt keinen Shell-Aufruf. Cygwin und MSYS PATH verwenden Doppelpunkte, die so uname sind für sie aufgerufen wird.

Beachten Sie, dass die Umgebungsvariable des Betriebssystems zum Erkennen von Windows verwendet werden kann, jedoch nicht zum Unterscheiden zwischen Cygwin und nativem Windows. Das Testen auf das Echo von Anführungszeichen funktioniert, erfordert jedoch einen Shell-Aufruf.

Leider fügt Cygwin der Ausgabe von uname einige Versionsinformationen hinzu, daher habe ich die Aufrufe 'patsubst' hinzugefügt, um sie in 'Cygwin' zu ändern. Außerdem hat uname für MSYS tatsächlich drei mögliche Ausgaben, beginnend mit MSYS oder MINGW, aber ich verwende auch patsubst, um alle nur in 'MSYS' umzuwandeln.

Wenn es wichtig ist, zwischen nativen Windows-Systemen mit und ohne uname.exe im Pfad zu unterscheiden, kann diese Zeile anstelle der einfachen Zuweisung verwendet werden:

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

Natürlich ist in allen Fällen GNU make erforderlich oder ein anderes make, das die verwendeten Funktionen unterstützt.

Ich bin heute auf dieses Problem gestoßen und brauchte es unter Solaris. Hier ist eine POSIX-Standardmethode, um dies zu tun (etwas sehr Nahes).

#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

Hier ist eine einfache Lösung, die überprüft, ob Sie sich in einer Windows- oder posix-ähnlichen Umgebung (Linux / Unix / Cygwin / Mac) befinden:

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

Es nutzt die Tatsache, dass Echo sowohl in posix-ähnlichen als auch in Windows-Umgebungen vorhanden ist und dass die Shell in Windows die Anführungszeichen nicht filtert.

Beachten Sie, dass Makefiles sehr empfindlich auf Abstände reagieren. Hier ist ein Beispiel für ein Makefile, das unter OS X einen zusätzlichen Befehl ausführt und unter OS X und Linux funktioniert. Insgesamt ist autoconf / automake jedoch der richtige Weg, um alles zu erreichen, was nicht trivial ist.

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
OBJECTS = http_client.o load.o lock.o search.o server.o thread.o Utility.o vor.o.

alle: vor

reinigen:
    rm -f $ (OBJEKTE) vor

vor: $ (OBJEKTE)
    $ (CPP) $ (LDFLAGS) -o vor $ (OBJEKTE)
ifeq ($ (UNAME), Darwin)
    # Legen Sie den Speicherort der Boost-Bibliothek fest
    install_name_tool -change libboost_system.dylib /nexopia/lib/libboost_system.dylib vor
endif

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

Eine andere Möglichkeit, dies zu tun, ist die Verwendung eines "configure" -Skripts. Wenn Sie bereits eine mit Ihrem Makefile verwenden, können Sie eine Kombination aus uname und sed verwenden, um die Dinge zum Laufen zu bringen. Führen Sie in Ihrem Skript zunächst Folgendes aus:

UNAME=uname

Um dies in Ihr Makefile aufzunehmen, beginnen Sie mit Makefile.in, das so etwas wie haben sollte

UNAME=@@UNAME@@

drin.

Verwenden Sie nach dem UNAME=unameBit den folgenden Befehl sed in Ihrem Konfigurationsskript .

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

Jetzt sollte Ihr Makefile UNAMEwie gewünscht definiert sein. Wenn / elif / else-Anweisungen alles sind, was übrig bleibt!

Ich hatte einen Fall, in dem ich den Unterschied zwischen zwei Fedora-Versionen feststellen musste, um die Befehlszeilenoptionen für inkscape zu optimieren:
- In Fedora 31 ist die Standard-Inkscape 1.0beta, die verwendet wird--export-file
- in Fedora <31 ist die Standard-Inkscape 0,92 die verwendet--export-pdf

Mein Makefile enthält Folgendes

# 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)=$@

Dies funktioniert, weil es /etc/os-releaseeine Zeile enthält

VERSION_ID=<value>

Der Shell-Befehl im Makefile gibt also die Zeichenfolge zurück VERSION_ID=<value>, und der Befehl eval wirkt darauf, um die Makefile-Variable festzulegen VERSION_ID. Dies kann natürlich für andere Betriebssysteme angepasst werden, je nachdem, wie die Metadaten gespeichert sind. Beachten Sie, dass es in Fedora keine Standardumgebungsvariable gibt, die die Betriebssystemversion angibt, sonst hätte ich das verwendet!