ОС обнаружение makefile

Ответ 1

Здесь уже много хороших ответов, но я хотел бы поделиться более полным примером того, что оба:

• не предполагает, что uname существует в Windows
• также обнаруживает процессор

Определенные здесь CCFLAGS необязательно рекомендуются или идеальны; они именно то, что проект, к которому я добавлял автоматическое обнаружение OS/CPU, был использован.

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

Ответ 2

Команда uname (http://developer.apple.com/documentation/Darwin/Reference/ManPages/man1/uname.1.html) без параметров сообщит вам имя операционной системы. Я бы использовал это, а затем создавал условия на основе возвращаемого значения.

Пример

UNAME := $(shell uname)

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

Ответ 3

Обнаружение операционной системы с помощью двух простых трюков:

• Сначала переменная окружения OS
• Затем команда uname

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

Или более безопасный способ, если не в Windows и uname недоступен:

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

Кен Джексон предлагает интересную альтернативу, если вы хотите отличить Cygwin/MinGW/MSYS/Windows. Посмотрите его ответ, который выглядит так:

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

Затем вы можете выбрать соответствующий материал в зависимости от 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

Заметки:

• Команда uname аналогична uname -s поскольку опция -s ( --kernel-name) является значением по умолчанию. Посмотрите, почему uname -s лучше, чем uname -o.

• Использование OS (вместо uname) упрощает алгоритм идентификации. Вы все равно можете использовать только uname, но вам нужно иметь дело с if/else блоками, чтобы проверить все версии MinGW, Cygwin и т.д.

• OS переменная окружения всегда установлена в "Windows_NT" в разных версиях Windows (см. Переменную среды %OS% в Википедии).

• Альтернативой OS является переменная среды MSVC (она проверяет наличие MS Visual Studio, см. Пример с использованием Visual C++).

Ниже приведен полный пример использования make и gcc для создания общей библиотеки: *.so или *.dll зависимости от платформы. Пример максимально прост, чтобы быть более понятным.

Для установки make и gcc в Windows см. Cygwin или MinGW.

Мой пример основан на пяти файлах

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

Напоминание: Makefile имеет отступы, используя табуляцию. Будьте осторожны при копировании в подпиксельные файлы.

Два файла Makefile

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 /questions/32112/how-to-check-if-running-in-cygwin-mac-or-linux/235204#235204
#    target = .....
#endif

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

$(target): hello.o
    gcc  $^  -shared  -o [email protected]
    # $^      => $^ expand to all prerequisites (after ':') => hello.o
    # -shared => Generate shared library
    # -o [email protected]   => Output file (-o) is [email protected] (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 /questions/32112/how-to-check-if-running-in-cygwin-mac-or-linux/235204#235204
#    target = .....
#endif

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

$(target): main.o
    gcc  $^  -L../lib  -lhello  -o [email protected]
    # $^       => $^ (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 [email protected]    => output file (-o) is [email protected] (target) = "app.exe" or "app"

Чтобы узнать больше, прочитайте документацию по автоматическим переменным, указанную cfi.

Исходный код

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

Сборка

Исправьте копию-копию Makefile (замените начальные пробелы на одну таблицу).

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

Команда make на обеих платформах одинакова. Данный вывод относится к 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'

Бег

Приложение должно знать, где находится общая библиотека.

В Windows простым решением является копирование библиотеки, в которой находится приложение:

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

В Unix-подобных операционных системах вы можете использовать LD_LIBRARY_PATH среды LD_LIBRARY_PATH:

> export LD_LIBRARY_PATH=lib

Запустите команду в Windows:

> app/app.exe
hello

Выполните команду в Unix-подобных операционных системах:

> app/app
hello

Ответ 4

Я недавно экспериментировал, чтобы ответить на этот вопрос, о котором я спрашивал себя. Вот мои выводы:

Поскольку в Windows вы не можете быть уверены, что команда uname доступна, вы можете использовать gcc -dumpmachine. Это покажет цель компилятора.

Также может возникнуть проблема при использовании uname если вы хотите выполнить кросс-компиляцию.

Вот пример списка возможного вывода gcc -dumpmachine:

• mingw32
• i686-рс-Cygwin
• x86_64-RedHat-линукс

Вы можете проверить результат в файле makefile следующим образом:

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

Это сработало для меня, но я не уверен, что это надежный способ получить тип системы. По крайней мере, она надежна в отношении MinGW и все, что мне нужно, поскольку для Windows не требуется иметь команду uname или MSYS.

Подводя итог, uname дает вам систему, на которой вы компилируете, и gcc -dumpmachine предоставляет вам систему, для которой вы компилируете.

Ответ 5

git makefile содержит многочисленные примеры того, как обойтись без autoconf/automake, но все же работать на множестве unixy-платформ.

Ответ 6

Обновление: теперь я считаю, что этот ответ устарел. Я отправил новое идеальное решение дальше.

Если ваш make файл может работать на не-Cygwin Windows, uname может быть недоступен. Это неудобно, но это потенциальное решение. Вы должны сначала проверить, чтобы Cygwin исключил это из-за наличия WINDOWS в своей PATH среды PATH.

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

Ответ 7

Это то, что GNU automake/autoconf предназначены для решения. Вы можете изучить их.

В качестве альтернативы вы можете установить переменные среды на разных платформах и сделать из них Makefile условным.

Ответ 8

Сегодня я столкнулся с этой проблемой, и мне это было нужно на Solaris, поэтому здесь есть стандартный способ POSIX (что-то очень близкое).

#Detect OS
UNAME = `uname`

# Build based on OS name
DetectOS:
    [email protected] $(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

Ответ 9

Обратите внимание, что Makefiles чрезвычайно чувствительны к интервалу. Вот пример Makefile, который выполняет дополнительную команду в OS X и работает на OS X и Linux. В целом, однако, autoconf/automake - это способ пойти на что-то вообще нетривиальным.

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

all: vor

clean:
    rm -f $(OBJECTS) vor

vor: $(OBJECTS)
    $(CPP) $(LDFLAGS) -o vor $(OBJECTS)
ifeq ($(UNAME),Darwin)
    # Set the Boost library location
    install_name_tool -change libboost_system.dylib /nexopia/lib/libboost_system.dylib vor
endif

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

Ответ 10

Другой способ сделать это - использовать "configure" script. Если вы уже используете его в своем make файле, вы можете использовать комбинацию uname и sed, чтобы заставить вещи работать. Во-первых, в script выполните следующие действия:

UNAME=uname

Затем, чтобы поместить это в ваш Makefile, начните с Makefile.in, который должен иметь что-то вроде

[email protected]@[email protected]@

в нем.

Используйте следующую команду sed в настройке script после бит UNAME=uname.

sed -e "s|@@[email protected]@|$UNAME|" < Makefile.in > Makefile

Теперь ваш make файл должен иметь UNAME, определенный по желанию. Если /elif/else - это все, что осталось!

Ответ 11

Вот простое решение, которое проверяет, находитесь ли вы в среде Windows или posix (Linux/Unix/Cygwin/Mac):

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

Он использует тот факт, что эхо существует как в posix-подобных, так и в Windows-средах, а в Windows оболочка не фильтрует кавычки.

Ответ 12

Я наконец нашел идеальное решение, которое решает эту проблему для меня.

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

Переменная UNAME устанавливается в Linux, Cygwin, MSYS, Windows, FreeBSD, NetBSD (или, предположительно, Solaris, Darwin, OpenBSD, AIX, HP-UX) или Unknown. Затем он может сравниваться по остальной части Makefile для разделения любых переменных и команд, зависящих от ОС.

Ключ в том, что Windows использует точки с запятой для разделения путей в переменной PATH, тогда как все остальные используют двоеточия. (Можно создать каталог Linux с именем ";" в имени и добавить его в PATH, что бы сломать это, но кто бы это сделал?) Это, по-видимому, наименее рискованный метод для обнаружения родной Windows, поскольку он не требует вызова оболочки. Cygwin и MSYS PATH используют двоеточия, поэтому для них вызывается uname.

Обратите внимание, что переменная среды OS может использоваться для обнаружения Windows, но не для того, чтобы различать Cygwin и родную Windows. Тестирование для эха кавычек работает, но для этого требуется вызов оболочки.

К сожалению, Cygwin добавляет некоторую информацию о версии к выводу uname, поэтому я добавил призывы "patsubst", чтобы изменить его на "Cygwin". Кроме того, uname для MSYS фактически имеет три возможных выхода, начиная с MSYS или MINGW, но я также использую patsubst, чтобы преобразовать все в просто "MSYS".

Если важно различать собственные системы Windows с и без некоторого uname.exe на пути, эта строка может использоваться вместо простого назначения:

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

Конечно, во всех случаях требуется GNU make или другой make, который поддерживает используемые функции.