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

250

Я обычно работаю на нескольких разных компьютерах и нескольких разных операционных системах, таких как 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
samoz
источник

Ответы:

283

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

  • не предполагает 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
Тревор Робинсон
источник
8
К сожалению, PROCESSOR_ARCHITECTUREenvvar кажется виртуализированным в зависимости от того, является ли процесс 32-битным или 64-битным. Так что, если у вас make32-разрядная версия, и вы пытаетесь создать 64-разрядное приложение, это не удастся. Использование его в сочетании с PROCESSOR_ARCHITEW6432работал для меня (см. Это и то )
Томас
4
Было бы неплохо, если бы makeкоманда добавила пару магических переменных с os и arch, вероятно, слишком много проблем.
Алекс
6
@JanusTroelsen: не важно, OSустановлен ли он в системах, отличных от Windows. Make обрабатывает unset так же, как empty, что вызывает переход к unameблоку на основе. Вам просто нужно добавить проверку FreeBSD там.
Тревор Робинсон
3
это ломает и на OSX. /bin/sh: -c: line 0: syntax error near unexpected token , Windows_NT '/ bin / sh: -c: строка 0:ifeq (,Windows_NT)' make: *** [os] Error 2
k107
1
@kristi Похоже, вы запускали это как команды оболочки, а не в контексте директив makefile.
phord
119

Команда 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
dbrown0708
источник
Просто чтобы быть точным, эта строка идет в вашем Makefile. Я только что попробовал эту конструкцию в Makefiles в Cygwin и OSX, и она работала, как и ожидалось. Что-то попробовать: наберите uname в командной строке. Это скажет вам ценность для этой ОС. OSX, скорее всего, будет "Дарвин".
dbrown0708
В проекте GnuWin32 есть и uname, и Gnu делают его доступным как родные приложения Windows, что делает эту технику переносимой на MingW из командной строки, а также на Cygwin в Windows.
RBerteig
Он не работает на моей машине Solaris, когда он находится внутри make-файла. Команда uname доступна в этой системе.
Самоз
4
Обратите внимание, что если вы поместите это внутрь Maketarget, оно не должно иметь отступ.
nylund
4
Разве синтаксис ": =" не специфичен для GNU Make?
Анкур Сетхи
40

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

  • Сначала переменная среды 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 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
olibre
источник
Я ценю ваши усилия, но главным вопросом было обнаружение операционной системы. Ваш пример обнаруживает только Linux и в остальном подразумевает Windows.
Шахбаз
Привет @Shahbaz. Вы правы, мой ответ не дает другого подхода, чем другие ответы. Более того, мой сценарий предполагает, что платформа - это Windows, а unameне Linux. Я привожу лишь один пример, который вам может не понадобиться, но это может помочь кому-то, кто ищет (в Интернете) способ реализации Makefileдля обеих платформ ;-) Что я должен изменить в своем ответе? Приветствия
olibre
Попробуйте найти способы правильно идентифицировать другие операционные системы! Цель состоит в том, чтобы найти метод, который не слишком сложен, но, что более важно, является пуленепробиваемым. То есть, он не совершил бы ошибку, несмотря ни на что.
Шахбаз
1
@olibre Спасибо за подробный пример, высоко ценю и помогает быстро начать работу. В lib/Makefileпримере targetиспользуется .soпротив .dll. Параллельный пример для app/makefileбудет полезен для сравнения empty stringvs .exeдля имени файла приложения. Например, я обычно не вижу app.exeв Unix-подобных ОС. ;-)
1
LSF? LFS? Опечатка?
Франклин Ю
19

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

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

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

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

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

Вы можете проверить результат в 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дает систему, для которой вы компилируете.

phsym
источник
Это хороший момент. Тем не менее, не unameидет с в MinGWлюбом случае? Тем не менее, дополнительная заметка о кросс-компиляции - это здорово.
Шахбаз
2
@Shahbaz MinGW setup может установить MSYS (который содержит uname), но это не обязательно. По-прежнему возможно найти системы только с инструментами MinGW gcc
phsym
1
Это нигде не работает. Clang является компилятором по умолчанию, как OS X и FreeBSD.
MarcusJ
@SebastianGodelet @MarcusJ Это легко исправить $(shell $(CC) -dumpmachine). Начиная с OS X Sierra, команда -dumpmachine работает на Clang.
Вортико
На OS X 10.12.5 это x86_64-apple-darwin16.6.0и работает Wether вас называют его gcc, ccили clang, но неcl
MarcusJ
17

Мерзавец Makefile содержит многочисленные примеры того , как обойтись без AUTOCONF / Automake, но по- прежнему работать на множестве платформ unixy.

JesperE
источник
13
Зная, что Git не использует Autofools, я чувствую себя оправданным в своем отвращении к ним ...
Дэн Молдинг
11
"Autofools"? Это была преднамеренная опечатка? :)
JesperE
6
Это было. Но, если подумать, я думаю, что мне нравится «Autostools» еще лучше. : D
Дэн Молдинг
Кстати, кого вы имели в виду под "их"? The Git или Autotools люди? : D
JesperE
8
Английский такой неточный язык. Как насчет этого: if (!usesAutotools(git)) aversionTo(autotools) = justified;Я также поясню, что это только инструменты, к которым я не склонен. Я уверен, что люди из Autotools - хорошие люди.
Дэн Молдинг
11

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

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

ifneq (,$(findstring /cygdrive/,$(PATH)))
    UNAME := Cygwin
else
ifneq (,$(findstring WINDOWS,$(PATH)))
    UNAME := Windows
else
    UNAME := $(shell uname -s)
endif
endif
Кен Джексон
источник
Это хорошо сейчас! Вы можете сказать мне одну вещь, хотя? Я не использую Cygwin, но у меня установлен MinGW с указанием пути к нему в PATH. Если я unameвыдаю из обычного терминала CMD, это дает мне MINGW. Я имею в виду, я до сих пор unameбез использования Cygwin. У меня также есть git bash, но я не пробовал uname на нем (сейчас я в Linux). Можете ли вы сказать мне, как эти два могут быть включены в ваш код?
Шахбаз
Если вы уверены, что uname доступен, это лучшее решение. Но в моей среде все используют Windows, и мало кто имеет установленный Cygwin или Mingw , поэтому я не могу гарантировать, что что-нибудь, даже стандартное, как uname, будет работать. В настоящее время у меня возникли некоторые трудности с приведенным выше кодом запуска make.exe в оболочке cmd. Windows - очень разочаровывающая платформа для работы.
Кен Джексон
Я имею в виду, что прежде чем проверять наличие WINDOWS в PATH, убедитесь, что вы не имеете дело с cygwin, как вы можете убедиться, что вы не имеете дело с MinGW? Например, возможно ли в Makefile проверить, может ли команда быть запущена, и если ее unameне удалось запустить, мы бы поняли, что мы находимся в Windows?
Шахбаз
Я изо всех сил пытаюсь найти чистое решение для этого Mingw / cygwin / shell-or-cmd / Linux. В конце концов, что-то вроде premake или cmake кажется лучшей идеей.
Исаак Некиттепас
Это больше не лучшее решение. Новое решение, которое я опубликовал, отличает родную Windows от поиска ';' в переменной PATH, без вызова оболочки.
Кен Джексон
7

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

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

Дуглас Лидер
источник
11
Я настоятельно рекомендую не использовать automake / autoconf. Они утомительны в использовании, увеличивают нагрузку на ваши файлы и время сборки. Они просто добавляют сложность для обычно очень маленького эффекта (все еще никакой переносимости между системами).
Йоханнес Оверман
1
Я просто потратил пару дней, чтобы научиться makeделать то, что я хочу. Теперь я тоже хочу попасть в automake / autoconf? - нет То, что можно сделать в make-файле, безусловно, должно быть сделано в make-файле, хотя бы для того, чтобы у меня не было нескольких точек остановки каждый раз, когда я хочу изменить compile & link.
инженер
Сколько платформ поддерживают ваши make-файлы? automake и autoconf действительно объединяются, когда вам нужна переносимость на многие платформы.
Дуглас Лидер
2
Я не буду требовать бесполезных зависимостей и менять всю систему сборки, чтобы узнать, для какой ОС она компилируется.
MarcusJ
7

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

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

Кен Джексон
источник
6

Я столкнулся с этой проблемой сегодня, и мне она понадобилась в 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
бедро
источник
1
Получение ошибки в OSX: «Makefile: 22: *** отсутствует разделитель. Стоп.». В этой строке: "- @ make $ (UNAME_S)".
Чарек Томчак,
Скорее всего, OSX не соответствует требованиям, поэтому попробуйте их по порядку. (1) Убедитесь, что вы используете TAB в качестве первого символа в строке (2) Удалите «- @» перед make (2a) Если 2 сработало, попробуйте один символ, а затем другой (3) Убедитесь, что UNAME_S определен, попробуйте echo $ (UNAME_S) вместо - @ make $ (UNAME_S)
Huckle
6

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

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

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

Самуил
источник
1
Совершенно небезопасно, так как $PATHможет относиться к другому echo(Мой делает ...)
yyny
@YoYoYonnY Почему ваш путь относится к другому эхо? Похоже, очень маловероятная ситуация.
Самуил
1
не совсем, git это делает, mingw делает, cygwin делает это ... И я лично поставил C: \ Windows \ System32 внизу моего пути.
yyny
1
Это «решение» «работает» для всех сред, но моя точка зрения заключается в том, что это определенно не обнаруживает окна безопасно. Если я хочу установить -mwindowsфлаг или выбрать между .dllили .so, это не получится.
yyny
1
@YoYoYonnY Спасибо за разъяснения. В моей ситуации я заботился только о том, был ли я в среде Cygwin, Windows или Linux, а не в какой ОС, в которой я находился, так что это было полезно для меня. Похоже, ваши потребности отличаются от моих.
Самуил
3

Обратите внимание, что 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

все: vor

чистый:
    rm -f $ (ОБЪЕКТЫ) vor

vor: $ (ОБЪЕКТЫ)
    $ (CPP) $ (LDFLAGS) -o vor $ (ОБЪЕКТЫ)
Ифек ($ (UNAME), Дарвин)
    # Установить расположение библиотеки Boost
    install_name_tool -change libboost_system.dylib /nexopia/lib/libboost_system.dylib vor
ENDIF

% .o:% .cpp $ (HEADERS) Makefile
    $ (CPP) $ (CPPFLAGS) -c $
ChrisInEdmonton
источник
2

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

UNAME=uname

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

UNAME=@@UNAME@@

в этом.

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

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

Теперь ваш make-файл должен быть UNAMEопределен как требуется. Если / elif / else заявления все, что осталось!

Шон
источник
Разве это не должно быть первым? UNAME = $ (uname)
Кен Джексон,
0

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

Патрик Б. Уоррен
источник