ОС обнаруживает make-файл

Я обычно работаю на нескольких разных компьютерах и в нескольких разных операционных системах, таких как Mac OS X, Linux или Solaris. Для проекта, над которым я работаю, я беру свой код из удаленного репозитория git.

Мне нравится иметь возможность работать над своими проектами независимо от того, на каком терминале я работаю. Пока что я нашел способы обойти изменения в ОС, меняя make-файл каждый раз, когда я переключаю компьютер. Однако это утомительно и вызывает множество головных болей.

Как я могу изменить свой make-файл, чтобы он определял, какую ОС я использую, и соответствующим образом изменял синтаксис?

Вот make-файл:

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

person samoz    schedule 03.04.2009    source источник


Ответы (13)


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

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

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

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
person Trevor Robinson    schedule 23.08.2012
comment
К сожалению, PROCESSOR_ARCHITECTURE envvar кажется виртуализированным в зависимости от того, является ли процесс 32-битным или 64-битным. Итак, если ваш make 32-битный, и вы пытаетесь создать 64-битное приложение, это не удастся. Использование его в сочетании с PROCESSOR_ARCHITEW6432 сработало для меня (см. this и это) - person Thomas; 29.11.2013
comment
Было бы неплохо, если бы команда make добавила пару волшебных переменных с os и arch, наверное, слишком много проблем. - person Alex; 25.08.2014
comment
это прерывается на FreeBSD, поскольку $OS не установлен. $OSTYPE может быть freebsd10.1. - person Janus Troelsen; 02.10.2015
comment
@JanusTroelsen: не имеет значения, установлен ли OS в системах, отличных от Windows. Сделать незаданное значение равно пустым, что приведет к переходу к блоку, основанному на uname. Вам просто нужно добавить туда проверку FreeBSD. - person Trevor Robinson; 02.10.2015
comment
это ломается и на osx. /bin/sh: -c: line 0: syntax error near unexpected token , Windows_NT '/ bin / sh: -c: строка 0: ifeq (,Windows_NT)' make: *** [os] Error 2 - person k107; 02.12.2016
comment
@kristi Похоже, вы запускали это как команды оболочки, а не в контексте директив makefile. - person phord; 24.03.2017
comment
Я получаю _1 _... - person Post Self; 01.07.2017
comment
uname -s на Cygwin возвращается с номером версии ОС. uname -o возвращает Cygwin и работает. uname -o в Linux - это «GNU / Linux» и нестандартный. Поэтому я просто использую -o для теста cygwin. - person rickfoosusa; 07.07.2017
comment
У меня Mac работает под управлением El Capitan и uname -p выводит i386, тогда как uname -m выводит x86_64 (как задокументировано другими) Так что, возможно, uname -m более надежен. - person drwatsoncode; 20.09.2017
comment
_1 _, _ 2_ и endif НЕ ДОЛЖНЫ иметь отступ (в моих экспериментах). Я также получил это только для работы вне целевых блоков - person Adam Straughan; 15.05.2018
comment
Я не могу согласиться с советом не предполагать, что uname существует. Насколько мне известно, не существует способа установить GNU Make без установки uname. - person burito; 12.07.2018
comment
поразительно похож на этот gist.github.com/sighingnow/deee806603ec9274fd47 - person mihaipopescu; 11.09.2018
comment
Переменная ОС остается установленной для Cygwin и MSYS, поэтому вы не можете использовать ее для различения Windows, Cygwin и MSYS. Но есть отличное решение. См. Внизу этой страницы. - person Ken Jackson; 11.09.2018

Команда 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
person dbrown0708    schedule 03.04.2009
comment
Чтобы быть точным, эта строка находится в вашем файле Makefile. Я просто попробовал эту конструкцию в Makefiles в Cygwin и OSX, и она сработала, как и ожидалось. Что можно попробовать: введите uname в командной строке. Это скажет вам ценность этой ОС. OSX, скорее всего, будет Дарвином. - person dbrown0708; 03.04.2009
comment
В проекте GnuWin32 как uname, так и Gnu доступны как собственные приложения Windows, что делает этот метод переносимым в MingW из командной строки, а также в Cygwin в Windows. - person RBerteig; 04.04.2009
comment
Он не работает на моей машине Solaris, когда он находится внутри файла makefile. Команда uname доступна в этой системе. - person samoz; 05.04.2009
comment
Это работало в OSX или Linux? Возможно ли, что вы используете не GNU make, а какой-то другой вариант? Если вы не используете GNU, возможно, стоит установить эту версию на вашем компьютере под Solaris, поскольку OSX и Linux будут работать под GNU. - person dbrown0708; 06.04.2009
comment
К вашему сведению, uname на Solaris (проверено на 9 и 10) сообщает SunOS - person basszero; 22.07.2009
comment
И вы можете использовать grep для возвращаемого значения из uname, если вас интересует только часть строки. См .: github.com/duncan-bayne/myfitnessdata/blob/master/Makefile < / а> - person Duncan Bayne; 16.02.2011
comment
Обратите внимание, что если вы поместите это в макетаргет, он не должен иметь отступа. - person nylund; 05.02.2012
comment
Разве синтаксис: = не специфичен для GNU Make? - person Ankur Sethi; 15.04.2012

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

  • Сначала переменная окружения 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

Примечания:


Ниже я привожу полный пример использования 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 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"

Чтобы узнать больше, прочтите документацию по автоматическим переменным. , как указано 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:

> export LD_LIBRARY_PATH=lib

Выполните команду в Windows:

> app/app.exe
hello

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

> app/app
hello
person oHo    schedule 08.02.2013
comment
Я ценю ваши усилия, но главный вопрос был в том, чтобы определить операционную систему. Ваш пример обнаруживает только Linux, а в остальном сразу предполагает Windows. - person Shahbaz; 09.02.2013
comment
Привет @Shahbaz. Вы правы, мой ответ не дает другого подхода, чем другие ответы. Более того, мой сценарий предполагает, что платформа - это Windows, а uname - не Linux. Я привожу только пример, который может вам не понадобиться, но это может помочь кому-то искать (в Интернете) способ реализации Makefile для обеих платформ ;-) Что мне следует изменить в своем ответе? Ваше здоровье - person oHo; 11.02.2013
comment
попробуйте придумать способы правильно идентифицировать и другие операционные системы! Цель состоит в том, чтобы найти метод, который не был бы слишком сложным, но, что более важно, был пуленепробиваемым. То есть, он не совершит ошибки ни при каких условиях. - person Shahbaz; 11.02.2013
comment
Привет @Shahbaz. Когда я найду более безопасный способ обнаружения платформы, я обновлю этот ответ ... на данный момент у меня недостаточно времени для расследования. Хороших выходных, ура ;-) - person oHo; 22.02.2013
comment
Привет @Shahbaz. Спустя более двух лет я наконец переработал свой ответ. Надеюсь, предложенной идентификации операционной системы будет достаточно пуленепробиваемости. Что вы думаете? Ваше здоровье - person oHo; 08.10.2015
comment
Опечатка? $^ => $^ is the first after ':' => Link hello.o - переменная $^ - это список всех предварительных требований, а не только первого. Как и в предыдущем примере, $< - это только первый. Документы здесь - person cfi; 03.11.2015
comment
Большое спасибо @cfi :-) Я также добавил вашу ссылку ;-) Ура - person oHo; 03.11.2015
comment
@olibre Спасибо за подробный пример, очень признателен и помогает мне быстро начать работу. В примере lib/Makefile target используется для .so vs .dll. Параллельный пример для app/makefile был бы полезен для сравнения empty string с .exe для имени файла приложения. Например, я обычно не вижу app.exe в Unix-подобных ОС. ;-) - person ; 23.05.2017
comment
Спасибо @ user314159 за отзыв ;-) Я только что отредактировал свой ответ. Я думаю, что ответ длиннее, чем раньше (например, app/Makefile двойной), но ответ более последовательный. Ваше здоровье ;-) - person oHo; 23.05.2017
comment
LSF? LFS? Опечатка? - person Franklin Yu; 12.02.2018
comment
Проблема с переменной среды ОС заключается в том, что она остается установленной в среде Cygwin. Вы не можете использовать его, чтобы отличить Cygwin от родной Windows. - person Ken Jackson; 28.08.2018
comment
Привет, @KenJackson. Спасибо за отзыв. Мой ответ предполагает, что мы хотим detected_OS=Windows, когда мы запускаем Cygwin или Mingw поверх Windows. Вам нужно различать Cygwin / Mingw / ...? - person oHo; 07.09.2018
comment
Cygwin и MSYS больше похожи на Linux, чем на Windows, поэтому важно различать их, если вы с ними работаете. Смотрите мое идеальное решение внизу страницы. - person Ken Jackson; 11.09.2018
comment
Привет, Кен. Спасибо, что отправили второй ответ. Ваш окончательный ответ потрясающий = ›+1 Я только что добавил ссылку в свой ответ, чтобы пригласить людей прочитать ваш ответ. Это нормально для вас? Ура, получайте удовольствие ;-) - person oHo; 07.10.2018

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

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

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

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

  • mingw32
  • i686-pc-cygwin
  • x86_64-Redhat-Linux

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

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, и это все, что мне нужно, поскольку для него не требуется наличие команды uname или пакета MSYS в Windows.

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

person phsym    schedule 10.09.2012
comment
Это хороший момент. Однако разве uname в любом случае не идет с MinGW? Тем не менее, еще одно замечание относительно кросс-компиляции - это здорово. - person Shahbaz; 11.09.2012
comment
@Shahbaz Установка MinGW может установить MSYS (который содержит uname), но это необязательно. По-прежнему можно найти системы только с инструментами MinGW gcc - person phsym; 11.09.2012
comment
Это не работает везде, где Clang является компилятором по умолчанию, как OS X и FreeBSD. - person MarcusJ; 20.06.2016
comment
@SebastianGodelet @MarcusJ Простое исправление - $(shell $(CC) -dumpmachine). Начиная с OS X Sierra, команда -dumpmachine работает с Clang. - person Vortico; 15.06.2017
comment
В OS X 10.12.5 это x86_64-apple-darwin16.6.0 и работает, если вы называете его gcc, cc или clang, но не cl - person MarcusJ; 25.06.2017

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

person JesperE    schedule 13.04.2009
comment
Зная, что Git не использует Autofools, я почему-то чувствую себя оправданным в моем отвращении к ним ... - person Dan Moulding; 12.06.2012
comment
Автофуги? Это была преднамеренная опечатка? :) - person JesperE; 12.06.2012
comment
Это было. Но если подумать, я думаю, что Autostools мне нравится даже больше. : D - person Dan Moulding; 12.06.2012
comment
Кстати, кого вы под ними имели в виду? Люди Git или Autotools? : D - person JesperE; 12.06.2012
comment
Английский - такой неточный язык. Как насчет этого: if (!usesAutotools(git)) aversionTo(autotools) = justified; Я также поясню, что это только инструменты, которые я не люблю. Я уверен, что люди из Autotools - хорошие люди. - person Dan Moulding; 12.06.2012

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

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

ifneq (,$(findstring /cygdrive/,$(PATH)))
    UNAME := Cygwin
else
ifneq (,$(findstring WINDOWS,$(PATH)))
    UNAME := Windows
else
    UNAME := $(shell uname -s)
endif
endif
person Ken Jackson    schedule 15.05.2012
comment
Это хорошо сейчас! Но ты можешь сказать мне одну вещь? Я не использую Cygwin, но у меня установлен MinGW с его путем bin в PATH. Если я выдаю uname с обычного терминала cmd, он дает мне MINGW. Я имею в виду, что у меня все еще uname без использования Cygwin. У меня тоже есть git bash, но uname на нем я не пробовал (сейчас я в Linux). Можете ли вы сказать мне, как эти два элемента могут быть включены в ваш код? - person Shahbaz; 16.05.2012
comment
Если вы уверены, что uname доступен, это лучшее решение. Но в моей среде все используют Windows, и мало у кого есть cygwin или mingw установлен, поэтому у меня нет гарантии, что что-нибудь, даже такое стандартное, как uname, будет работать. В настоящее время у меня возникают проблемы с приведенным выше кодом, запускающим make.exe в оболочке cmd. Windows - очень неприятная платформа для работы. - person Ken Jackson; 18.05.2012
comment
Я имею в виду, что перед тестированием существования WINDOWS в PATH вы должны убедиться, что вы не имеете дело с cygwin, как вы можете убедиться, что вы не имеете дело с MinGW? Например, можно ли в Makefile проверить, можно ли запустить команду, и если uname не может быть запущен, мы бы поняли, что находимся в Windows? - person Shahbaz; 18.05.2012
comment
Я изо всех сил пытаюсь найти чистое решение для этого Mingw / cygwin / shell-or-cmd / Linux. В конце концов, лучшая идея - это что-то вроде premake или cmake. - person Isaac Nequittepas; 22.04.2013
comment
Это уже не лучшее решение. Новое решение, которое я опубликовал, отличает родную Windows по запросу ';' в переменной PATH без вызова оболочки. - person Ken Jackson; 28.08.2018

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

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

person Douglas Leeder    schedule 03.04.2009
comment
Я настоятельно не рекомендую использовать automake / autoconf. Они утомительны в использовании, добавляют много накладных расходов вашим файлам и сокращают время сборки. Они просто добавляют сложность, обычно с очень небольшим эффектом (при этом отсутствует переносимость между системами). - person Johannes Overmann; 04.11.2013
comment
Я просто потратил пару дней на то, чтобы научить make делать то, что я хочу. Хочу ли я теперь также войти в automake / autoconf? - НЕТ. Что можно сделать в make-файле, безусловно, должно быть сделано в make-файле, хотя бы для того, чтобы у меня не было нескольких точек остановки каждый раз, когда я хочу изменить компиляцию и ссылку. - person Engineer; 04.07.2015
comment
Сколько платформ поддерживают ваши make-файлы? automake и autoconf действительно пригодятся, когда вам нужна переносимость на многие платформы. - person Douglas Leeder; 06.07.2015
comment
Я не собираюсь требовать бесполезных зависимостей и менять всю свою систему сборки только для того, чтобы узнать, для какой ОС она компилируется. - person MarcusJ; 20.06.2016

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

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.

Обратите внимание, что переменная среды ОС может использоваться для обнаружения 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, который поддерживает используемые функции.

person Ken Jackson    schedule 28.08.2018

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

#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
person Huckle    schedule 24.04.2012
comment
Получение ошибки в OSX: Makefile: 22: *** отсутствует разделитель. Стоп .. На этой строке: - @ make $ (UNAME_S). - person Czarek Tomczak; 13.02.2014
comment
OSX, скорее всего, не соответствует требованиям, поэтому попробуйте их по порядку. (1) Убедитесь, что вы используете TAB в качестве первого символа в строке (2) Удалите - @ перед make (2a) Если 2 сработало, попробуйте один символ, а затем другой (3) Убедитесь, что UNAME_S определено, попробуйте echo $ (UNAME_S) вместо - @ make $ (UNAME_S) - person Huckle; 16.02.2014

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

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

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

person Samuel    schedule 14.05.2015
comment
Совершенно небезопасно, поскольку $PATH может относиться к другому echo (у меня есть ...) - person yyny; 16.04.2016
comment
@YoYoYonnY Почему ваш путь ссылается на другое эхо? Похоже на очень маловероятную ситуацию. - person Samuel; 20.04.2016
comment
не совсем, git делает это, mingw делает это, cygwin делает это ... И я лично помещал C: \ Windows \ System32 в конец пути. - person yyny; 20.04.2016
comment
@YoYoYonnY Конечно, Cygwin делает это, и это решение работает для Cygwin. Обратите внимание, что мой ответ предназначен для обнаружения среды, подобной posix (POSIX, как в Linux / Unix / Mac), каковой является Cygwin. То же самое, вероятно, верно и для вашей среды git (я предполагаю, bash). - person Samuel; 21.04.2016
comment
Это решение работает для всех сред, но я считаю, что это определенно не обеспечивает безопасное обнаружение окон. Если я хочу установить флаг -mwindows или выбрать между .dll или .so, это не сработает. - person yyny; 21.04.2016
comment
@YoYoYonnY Спасибо за разъяснения. В моей ситуации меня волновало только то, нахожусь ли я в среде Cygwin, Windows или Linux, а не в какой ОС я был, так что это было полезно для меня. Похоже, ваши потребности отличаются от моих. - person Samuel; 22.04.2016
comment
да, $ (OS) кажется немного безопаснее, хотя это всего лишь переменная среды. - person yyny; 22.04.2016
comment
Мне нравится это решение, спасибо - person wukong; 18.04.2019

Обратите внимание, что файлы Makefile очень чувствительны к интервалу. Вот пример 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 $
person ChrisInEdmonton    schedule 01.10.2009

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

UNAME=uname

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

UNAME=@@UNAME@@

in it.

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

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

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

person Sean    schedule 04.08.2011
comment
Разве первый не должен быть таким? UNAME = $ (uname) - person Ken Jackson; 05.01.2019

У меня был случай, когда мне пришлось обнаружить разницу между двумя версиями Fedora, чтобы настроить параметры командной строки для inkscape:
- в Fedora 31 inkscape по умолчанию - 1.0beta, который использует --export-file
- в Fedora ‹31, inkscape по умолчанию - 0.92, который использует --export-pdf

Мой Makefile содержит следующее

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

Это работает, потому что /etc/os-release содержит строку

VERSION_ID=<value>

поэтому команда оболочки в Makefile возвращает строку VERSION_ID=<value>, затем команда eval воздействует на это, чтобы установить переменную Makefile VERSION_ID. Очевидно, это можно настроить для других ОС в зависимости от того, как хранятся метаданные. Обратите внимание, что в Fedora нет переменной среды по умолчанию, которая указывает версию ОС, иначе я бы ее использовал!

person Patrick B Warren    schedule 13.03.2020