Как запустить makefile в Linux

Обновлено: 21.11.2024

Компиляция файлов исходного кода может быть утомительной, особенно если вы хотите включить несколько исходных файлов и должны каждый раз вводить команду компиляции.
Что ж, у меня есть новости для вас... Ваши дни компиляции командной строки (в основном) закончились, потому что ВЫ научитесь писать Makefiles.
Makefiles — это файлы специального формата, которые вместе с утилитой make помогут вам автоматически создавать проекты и управлять ими.
Для этого сеанса вам понадобятся следующие файлы:
main.cpphello.cppfactorial.cppfunctions.h Я рекомендую создать новый каталог и поместить туда все файлы.
Примечание: для компиляции я использую g++. Вы можете изменить его на компилятор по вашему выбору
Утилита make Если вы запустите

эта программа будет искать файл с именем
makefile в вашем каталоге, а затем выполнять его.

Если у вас есть несколько make-файлов, вы можете выполнить их с помощью команды:

В утилите
make есть несколько других переключателей. Для получения дополнительной информации
человек делает .
Процесс сборки

Компилятор берет исходные файлы и выводит объектные файлы. Линковщик берет объектные файлы и создает исполняемый файл.

Компиляция вручную Тривиальный способ скомпилировать файлы и получить исполняемый файл — запустить команду:

Основной Makefile Базовый makefile состоит из:

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

[Загрузить
здесь]
Чтобы запустить этот make-файл для ваших файлов, введите:

В этом первом примере мы видим, что наша цель называется
all. Это цель по умолчанию для make-файлов. Утилита
make выполнит эту цель, если не указана другая.

Мы также видим, что для target
all нет зависимостей, поэтому
make безопасно выполняет указанные системные команды.

Наконец make компилирует программу в соответствии с заданной нами командной строкой.

Использование зависимостей Иногда полезно использовать разные цели. Это связано с тем, что если вы изменяете один файл в своем проекте, вам не нужно перекомпилировать все, а только то, что вы изменили.

Вот пример:

[Скачать
здесь]
Теперь мы видим, что цель all имеет только зависимости, но не системные команды. Чтобы make выполнялся правильно, он должен соответствовать всем зависимостям вызываемой цели (в данном случае всем).
Каждая из зависимостей просматривается по всем доступным целям и выполняется, если найдена.
В этом примере мы видим цель с именем clean. Полезно иметь такую цель, если вы хотите быстро избавиться от всех объектных файлов и исполняемых файлов.
Использование переменных и комментариев Вы также можете использовать переменные при написании Makefile. Это удобно в ситуациях, когда вы хотите изменить компилятор или параметры компилятора.

[Скачать
здесь]
Как видите, иногда переменные могут быть очень полезными. Чтобы использовать их, просто присвойте значение переменной, прежде чем вы начнете писать свои цели. После этого вы можете просто использовать их с оператором разыменования $(VAR).
Что делать дальше С помощью этого краткого введения в Makefiles вы можете создать очень сложный механизм для компиляции ваших проектов. Однако это лишь верхушка айсберга. Я не ожидаю, что кто-то полностью поймет пример, представленный ниже, не ознакомившись с некоторой
документацией по Make (которую мне пришлось сделать самому) или не прочитав страницы 347–354 вашей книги по Unix.

[Скачать
здесь]
Если вы понимаете этот последний пример, вы можете адаптировать его к своим личным проектам, изменив только 2 строки, независимо от того, сколько у вас дополнительных файлов.

Makefiles используются, чтобы решить, какие части большой программы необходимо перекомпилировать. В подавляющем большинстве случаев компилируются файлы C или C++. Другие языки обычно имеют свои собственные инструменты, которые служат той же цели, что и Make. Его можно использовать и вне программ, когда вам нужна серия инструкций для запуска в зависимости от того, какие файлы были изменены. В этом руководстве основное внимание будет уделено варианту использования компиляции C/C++.

Вот пример графика зависимостей, который можно построить с помощью Make. Если зависимости какого-либо файла изменятся, файл будет перекомпилирован:

Какие альтернативы есть?

Популярными альтернативными системами сборки C/C++ являются SCons, CMake, Bazel и Ninja. Некоторые редакторы кода, такие как Microsoft Visual Studio, имеют собственные встроенные инструменты сборки. Для Java есть Ant, Maven и Gradle. Другие языки, такие как Go и Rust, имеют собственные инструменты сборки.

Интерпретируемые языки, такие как Python, Ruby и Javascript, не требуют аналога Makefile. Цель Makefiles состоит в том, чтобы скомпилировать все файлы, которые необходимо скомпилировать, на основе того, какие файлы были изменены. Но когда файлы на интерпретируемых языках изменяются, ничего не нужно перекомпилировать.При запуске программы используется самая последняя версия файла.

Версии и типы Make

Существует множество реализаций Make, но большая часть этого руководства будет работать с любой версией, которую вы используете. Однако он специально написан для GNU Make, который является стандартной реализацией в Linux и MacOS. Все примеры работают для версий Make 3 и 4, которые почти эквивалентны, за исключением некоторых эзотерических отличий.

Запуск примеров

Чтобы запустить эти примеры, вам понадобится терминал и установленный make. Для каждого примера поместите содержимое в файл с именем Makefile и в этом каталоге запустите команду make. Начнем с самого простого Makefile:

Вот результат выполнения приведенного выше примера:

Вот оно! Если вы немного запутались, вот видео, в котором рассматриваются эти шаги, а также описывается базовая структура файлов Makefile.

Синтаксис Makefile

Makefile состоит из набора правил. Обычно правило выглядит так:

Цели — это имена файлов, разделенные пробелами. Как правило, для каждого правила существует только одно правило.
команды представляют собой последовательность шагов, обычно используемых для создания целей. Они должны начинаться с символа табуляции, а не с пробела.
Необходимые условия – это также имена файлов, разделенные пробелами. Эти файлы должны существовать до запуска команд для цели. Их также называют зависимостями

Примеры для начинающих

Следующий Makefile содержит три отдельных правила. Когда вы запускаете команду make blah в терминале, она создает программу с именем blah в несколько шагов:

Make получает в качестве цели blah, поэтому он сначала ищет эту цель.
blah требует blah.o , так что выполните поиск цели blah.o
blah.o требует blah.c , поэтому выполните поиск цели blah.c
blah.c не имеет зависимостей, поэтому выполняется команда echo
Затем выполняется команда cc -c, так как все зависимости blah.o завершены
Выполняется команда top cc, так как все бла-зависимости завершены
Вот оно: blah — это скомпилированная программа на C.

У этого make-файла есть единственная цель, которая называется some_file. Целью по умолчанию является первая цель, поэтому в этом случае будет запущен some_file.

Этот файл в первый раз создаст файл some_file, а во второй раз заметит, что он уже создан, в результате чего make: 'some_file' будет обновлен.

Здесь целевой файл some_file "зависит" от other_file . Когда мы запустим make, будет вызвана цель по умолчанию (some_file, поскольку она первая). Сначала он просматривает свой список зависимостей и, если какая-либо из них старше, сначала запускает цели для этих зависимостей, а затем запускает себя. При втором запуске ни одна цель не будет запущена, поскольку обе цели существуют.

Это всегда будет запускать обе цели, потому что some_file зависит от other_file, который никогда не создается.

clean часто используется как цель, которая удаляет вывод других целей, но это не специальное слово в make .

Переменные

Переменные могут быть только строками. Обычно вы хотите использовать := , но = также работает. См. Переменные, часть 2.

Вот пример использования переменных:

Ссылка на переменные с помощью $<> или $()

Все цели

Вы создаете несколько целей и хотите, чтобы они все выполнялись? Сделать цель "все".

Несколько целей

Если для правила задано несколько целей, команды будут выполняться для каждой цели.
$@ — это автоматическая переменная, содержащая имя цели.

* Подстановочный знак

И *, и % в Make называются подстановочными знаками, но они означают совершенно разные вещи. * ищет в вашей файловой системе совпадающие имена файлов. Я предлагаю вам всегда заключать его в функцию подстановочного знака, потому что в противном случае вы можете попасть в распространенную ловушку, описанную ниже.

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

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

Опасно: если * не соответствует ни одному файлу, он остается как есть (если только не запустить функцию подстановочного знака)

% Подстановочный знак

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

При использовании в режиме "соответствия" он соответствует одному или нескольким символам в строке. Это совпадение называется основой.
При использовании в режиме "замены" он берет совпадающую основу и заменяет ее в строке.
% чаще всего используется в определениях правил и в некоторых конкретных функциях.

Посмотрите в этих разделах примеры его использования:

Автоматические переменные

Существует много автоматических переменных, но часто отображаются лишь некоторые из них:

Неявные правила

Занимайтесь любовью c подборкой.И каждый раз, когда он выражает свою любовь, все становится запутанным. Возможно, самая запутанная часть Make — это создаваемые магические/автоматические правила. Make называет эти «неявные» правила. Я лично не согласен с этим дизайнерским решением и не рекомендую их использовать, но они часто используются, и поэтому их полезно знать. Вот список неявных правил:

Компиляция программы C: n.o автоматически создается из n.c с помощью команды вида $(CC) -c $(CPPFLAGS) $(CFLAGS)
Компиляция программы на C++: n.o автоматически создается из n.cc или n.cpp командой вида $(CXX) -c $(CPPFLAGS) $(CXXFLAGS)
Связывание одного объектного файла: n создается автоматически из n.o при выполнении команды $(CC) $(LDFLAGS) n.o $(LOADLIBES) $(LDLIBS)

CC : Программа для компиляции программ на C; копия по умолчанию
CXX : Программа для компиляции программ на C++; г++ по умолчанию
CFLAGS: дополнительные флаги для компилятора C.
CXXFLAGS: дополнительные флаги для компилятора C++.
CPPFLAGS: дополнительные флаги для препроцессора C.
LDFLAGS: дополнительные флаги для компиляторов, когда они должны вызывать компоновщик.

Давайте посмотрим, как теперь мы можем построить программу на C, даже не сообщая Make явно, как выполнять компиляцию:

Правила статического шаблона

Правила статического шаблона — это еще один способ сократить количество записей в Makefile, но я бы сказал, что они более полезны и менее «волшебны». Вот их синтаксис:

Суть в том, что заданная цель соответствует целевому шаблону (через подстановочный знак %). Все, что было сопоставлено, называется основой. Затем основа подставляется в шаблон prereq-pattern для создания предварительных требований цели.

Типичный пример использования — компиляция файлов .c в файлы .o. Вот ручной способ:

Вот более эффективный способ с использованием правила статического шаблона:

Правила статического шаблона и фильтр

Хотя позже я расскажу о функциях, я расскажу, что вы можете с ними делать. Функцию фильтра можно использовать в правилах статического шаблона для сопоставления правильных файлов. В этом примере я создал расширения .raw и .result.

Правила шаблона

Правила шаблона используются часто, но они довольно запутаны. Вы можете смотреть на них двумя способами:

Способ определения собственных неявных правил
Упрощенная форма правил статического шаблона.

Начнем с примера:

Правила шаблона содержат "%" в цели. Этот «%» соответствует любой непустой строке, а остальные символы соответствуют самим себе. «%» в предпосылке шаблонного правила означает ту же основу, которая соответствует «%» в целевом объекте.

Вот еще один пример:

Правила двойного двоеточия

Правила с двойным двоеточием используются редко, но позволяют определить несколько правил для одной и той же цели. Если бы это были одиночные двоеточия, было бы напечатано предупреждение, и был бы запущен только второй набор команд.

Эхо команды/отключение звука

Добавьте @ перед командой, чтобы она не печаталась
Вы также можете запустить make с параметром -s, чтобы добавить @ перед каждой строкой

Выполнение команды

Каждая команда запускается в новой оболочке (или, по крайней мере, эффект такой же)

Оболочка по умолчанию

Оболочкой по умолчанию является /bin/sh . Вы можете изменить это, изменив переменную SHELL:

Обработка ошибок с помощью -k , -i и -

Добавьте -k при запуске make, чтобы продолжить работу даже при возникновении ошибок. Полезно, если вы хотите увидеть все ошибки Make сразу.
Добавьте - перед командой, чтобы подавить ошибку
Добавьте -i, чтобы это происходило для каждой команды.

Прерывание или уничтожение команды make

Только примечание: если вы нажмете Ctrl+C, он удалит только что созданные новые цели.

Рекурсивное использование make

Чтобы рекурсивно вызвать make-файл, используйте специальный $(MAKE) вместо make, потому что он передаст вам флаги make и не будет зависеть от них.

Использовать экспорт для рекурсивного создания

Директива export берет переменную и делает ее доступной для вложенных команд make. В этом примере файл cooly экспортируется таким образом, что его может использовать make-файл в подкаталоге.

Примечание: экспорт имеет тот же синтаксис, что и sh, но они не связаны между собой (хотя и похожи по функциям)

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

.EXPORT_ALL_VARIABLES экспортирует все переменные для вас.

Аргументы

Есть хороший список опций, которые можно запустить из make. Проверьте --dry-run , --touch , --old-file .

У вас может быть несколько целей, например make clean run test запускает чистую цель, затем запускает , а затем проверяет .

Варианты и модификации

Существует две разновидности переменных:

рекурсивный (использовать = ) — переменные ищутся только тогда, когда команда используется, а не когда она определена.
просто расширяется (используйте := ) — как обычное императивное программирование — расширяются только те, которые определены до сих пор

Простое раскрытие (с помощью := ) позволяет добавить к переменной. Рекурсивные определения дадут ошибку бесконечного цикла.

?= устанавливает переменные только в том случае, если они еще не были установлены

Пробелы в конце строки не удаляются, а пробелы в начале удаляются. Чтобы создать переменную с одним пробелом, используйте $(nullstring)

Неопределенная переменная на самом деле является пустой строкой!

Подстановка строк также является очень распространенным и полезным способом изменения переменных. Также ознакомьтесь с текстовыми функциями и функциями имен файлов.

Аргументы командной строки и переопределение

Вы можете переопределить переменные, поступающие из командной строки, с помощью override . Здесь мы запустили команду make option_one=hi

Список команд и определение

"define" на самом деле просто список команд. Это не имеет ничего общего с функцией. Обратите внимание, что это немного отличается от точки с запятой между командами, потому что каждая из них запускается в отдельной оболочке, как и ожидалось.

Целевые переменные

Переменные можно назначать для определенных целей

Переменные шаблона

Вы можете назначать переменные для определенных целевых шаблонов

Условие if/else

Проверить, пуста ли переменная

Проверить, определена ли переменная

ifdef не расширяет ссылки на переменные; он просто видит, определено ли что-то вообще

$(сделать флаги)

В этом примере показано, как тестировать флаги make с помощью findstring и MAKEFLAGS . Запустите этот пример с make -i, чтобы увидеть, как он распечатывает оператор echo.

Первые функции

Функции в основном предназначены только для обработки текста. Вызывайте функции с помощью $(fn, arguments) или $ . Вы можете сделать свой собственный, используя встроенную функцию вызова. Make имеет приличное количество встроенных функций.

Если вы хотите заменить пробелы или запятые, используйте переменные

НЕ включайте пробелы в аргументы после первого. Это будет рассматриваться как часть строки.

Подстановка строк

$(patsubst pattern,replacement,text) выполняет следующие действия:

"Находит в тексте слова, разделенные пробелами, которые соответствуют шаблону, и заменяет их заменой. Здесь шаблон может содержать '%', который действует как подстановочный знак, соответствующий любому количеству любых символов в слове. Если замена также содержит ' %», «%» заменяется текстом, совпадающим с «%» в шаблоне. Таким образом обрабатывается только первый «%» в шаблоне и замене; все последующие «%» не изменяются». (документы GNU)

Ссылка подстановки $(text:pattern=replacement) является сокращением для этого.

Есть еще одно сокращение, которое заменяет только суффиксы: $(text:suffix=replacement) . Здесь не используется подстановочный знак %.

Примечание: не добавляйте дополнительные пробелы для этого сокращения. Он будет рассматриваться как условие поиска или замены.

Функция foreach

Функция foreach выглядит следующим образом: $(foreach var,list,text) . Он преобразует один список слов (разделенных пробелами) в другой. var устанавливается для каждого слова в списке, и текст расширяется для каждого слова.
Это добавляет восклицательный знак после каждого слова:

Функция если

if проверяет, не пуст ли первый аргумент. В этом случае запускается второй аргумент, в противном случае запускается третий.

Функция вызова

Make поддерживает создание базовых функций. Вы «определяете» функцию, просто создавая переменную, но используя параметры $(0) , $(1) и т. д. Затем вы вызываете функцию с помощью специальной функции вызова. Синтаксис: $(переменная вызова,параметр,парам) . $(0) — это переменная, а $(1) , $(2) и т. д. — это параметры.

Функция оболочки

оболочка — вызывает оболочку, но перевод строки заменяется пробелами!

Включить Makefile

Директива include сообщает make прочитать один или несколько других make-файлов. Это строка в файле makefile, которая выглядит следующим образом:

Это особенно полезно, когда вы используете такие флаги компилятора, как -M, которые создают файлы Makefile на основе исходного кода. Например, если некоторые файлы c содержат заголовок, этот заголовок будет добавлен в Makefile, написанный gcc. Подробнее об этом я рассказываю в Makefile Cookbook

Директива vpath

Используйте vpath, чтобы указать, где существует некоторый набор предварительных требований. Формат vpath

может иметь % , который соответствует любому нулю или более символов.
Вы также можете сделать это глобально с помощью переменной VPATH

Многострочный

Символ обратной косой черты ("\") дает нам возможность использовать несколько строк, когда команды слишком длинные

.фони

Добавление .PHONY к цели не позволит make перепутать фальшивую цель с именем файла. В этом примере, если файл clean создан, make clean все равно будет запущен. .PHONY удобен в использовании, но я не буду использовать его в остальных примерах для простоты.

.delete_on_error

Инструмент make прекратит выполнение правила (и вернется к предварительным требованиям), если команда возвращает ненулевой статус выхода.
DELETE_ON_ERROR удалит цель правила, если правило не работает таким образом. Это произойдет для всех целей, а не только для той, что была раньше, как PHONY. Рекомендуется всегда использовать это, даже если make не делает этого по историческим причинам.

Давайте рассмотрим действительно сочный пример Make, который хорошо работает для проектов среднего размера.

Преимущество этого make-файла в том, что он автоматически определяет для вас зависимости. Все, что вам нужно сделать, это поместить файлы C/C++ в папку src/.

В Unix-подобных операционных системах make — это утилита для создания и поддержки групп программ (и других типов файлов) из исходного кода.

Эта страница посвящена версии make для GNU/Linux.

Описание

Задачей утилиты make является автоматическое определение частей большой программы, которые необходимо перекомпилировать, и выполнение команд, необходимых для их повторной компиляции. В этой документации описывается реализация GNU команды make, написанная Ричардом Столлманом и Роландом Макгратом и в настоящее время поддерживаемая Полом Смитом. Многие из приведенных ниже примеров показывают программы на C, поскольку они наиболее распространены, но вы можете использовать make с любым языком программирования, компилятор которого можно запустить с помощью команды оболочки. На самом деле make не ограничивается программами. Вы можете использовать его для описания любой задачи, в которой одни файлы должны автоматически обновляться из других при изменении других.

Чтобы подготовиться к использованию make, вы должны написать файл с именем makefile, в котором описаны отношения между файлами в вашей программе и указаны команды для обновления каждого файла. В программе обычно исполняемый файл обновляется из объектных файлов, которые, в свою очередь, создаются путем компиляции исходных файлов.

После того, как подходящий make-файл существует, каждый раз, когда вы изменяете некоторые исходные файлы, эта простая команда оболочки:

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

make выполняет команды в make-файле для обновления одного или нескольких целевых имен, где name обычно является программой. Если опция -f отсутствует, make будет искать make-файлы GNUmakefile, makefile и Makefile в указанном порядке.

Обычно make-файл следует называть либо makefile, либо Makefile. (Официально рекомендуемое имя — Makefile, поскольку оно отображается в начале списка каталогов, рядом с другими важными файлами, такими как README.) Первое выбранное имя, GNUmakefile, не рекомендуется для большинства make-файлов. Вы должны использовать это имя, если у вас есть make-файл, специфичный для GNU make, и он не будет понят другими версиями make. Если makefile представляет собой тире ("-"), читается стандартный ввод.

сделать обновления целью, если она зависит от необходимых файлов, которые были изменены с момента последнего изменения цели, или если цель не существует.

Синтаксис

Параметры

< /tr> < td> Исключите использование встроенных неявных правил. Кроме того, очистите список суффиксов по умолчанию для суффиксных правил.

-b, -m	Эти параметры игнорируются, но включены для совместимости с другими версиями make.
-B, --always-make	Безусловно сделать все цели.
-C dir, --directory=dir	Перейдите в каталог dir, прежде чем читать make-файлы или делать что-либо еще. Если указано несколько опций -C, каждая из них интерпретируется относительно предыдущей: -C / -C и т.д. эквивалентны -C /etc. Обычно используется с рекурсивными вызовами make.
-d	Печать отладочной информации в дополнение к обычной обработке. В отладочной информации говорится, какие файлы рассматриваются для переделки, какое время файла сравнивается и с какими результатами, какие файлы действительно необходимо переделать, какие неявные правила учитываются и применяются; все интересное о том, как make решает, что делать.
--debug[=FLAGS]	Печать отладочной информации в дополнение к обычной обработке. Если ФЛАГИ опущены, то поведение такое же, как если бы была указана опция -d. ФЛАГИ могут быть a для всего вывода отладки (так же, как при использовании -d), b для базовой отладки, v для более подробной базовой отладки, i для отображения неявных правил, j для подробностей о вызове команд и m для отладки при переделке make-файлов.
-e, --environment-overrides	Приоритет переменных, взятых из среды, над переменными из make-файлов.
-f файл, --file=файл, --makefile=файл< /td>	Использовать файл в качестве make-файла.
-i, --ignore-errors	Игнорировать все ошибки в командах, выполняемых для переделки файлов.
-I dir, --include-dir=dir	Указывает каталог < i>dir для поиска включенных make-файлов. Если для указания нескольких каталогов используется несколько опций -I, поиск в каталогах выполняется в указанном порядке. В отличие от аргументов других флагов make, каталоги, указанные с флагами -I, могут идти сразу после флага: разрешено -Idir, а также -I dir. Этот синтаксис разрешен для совместимости с флагом -I препроцессора C.
-j [jobs], --jobs[=jobs ]	Указывает количество заданий (команд), которые должны выполняться одновременно. Если имеется более одной опции -j, действует последняя. Если опция -j указана без аргумента, make не будет ограничивать количество заданий, которые могут выполняться одновременно.
-k, --keep-going	Продолжать как можно дольше после ошибки. В то время как сбойный таргет (и те, что от него зависят) нельзя переделать, остальные зависимости этих таргетов все равно можно обработать.
-l [ load], --load-average[=load]	Указывает, что новые задания (команды) не должны запускаться, если есть другие задания работает, а средняя нагрузка не ниже load (число с плавающей запятой). Без аргумента удаляет предыдущий предел загрузки.
-L, --check-symlink-times	Используйте самое последнее время модификации между символическими ссылками и целью.
-n, --just-print, --dry-run, --recon	Вывести команды, которые должны быть выполнены, но не выполнять их.
-o file, --old-file=file< /i>, --assume-old=file	Не переделывать файл file, даже если он старше своих зависимостей , и ничего не переделывать из-за изменений в файле. По сути, файл считается очень старым, а его правила игнорируются.
-p, --print-data-base	Распечатать базу данных (правила и значения переменных), полученные в результате чтения make-файлов; затем выполните как обычно или как указано иным образом. Это также распечатывает информацию о версии, заданную параметром -v (см. ниже). Чтобы распечатать базу данных, не пытаясь переделать какие-либо файлы, используйте make -p -f/dev/null.
-q, --question	" Режим вопросов». Не запускайте никаких команд и ничего не печатайте; просто верните нулевой статус выхода, если указанные цели уже обновлены, и ненулевой в противном случае.
-r, --no-builtin-rules
-R, --no-builtin-variables	Не определять никаких встроенных -в переменных.
-s, --silent, --quiet	Тихая работа; не печатать команды по мере их выполнения.
-S, --no-keep-going, --stop	Отмена действие опции -k. В этом нет необходимости, за исключением рекурсивного make, где -k может быть унаследован от make верхнего уровня через MAKEFLAGS или если вы установили -k в MAKEFLAGS в вашей среде.
- t, --touch	Прикоснитесь к файлам (пометьте их как актуальные, не изменяя их на самом деле) вместо того, чтобы запускать их команды. Это используется, чтобы сделать вид, что команды были выполнены, чтобы обмануть будущие вызовы make.
-v, --version	Вывести версию make ; также Copyright, список авторов и уведомление об отсутствии гарантии.
-w, --print-directory	Напечатать сообщение, содержащее рабочий каталог до и после другой обработки. Это может быть полезно для отслеживания ошибок из-за сложных гнезд рекурсивных команд make.
--no-print-directory	Выключите -w, даже если он был включен неявно.
-W file, --what-if=file, --new-file=file, --assume-new=file	Представить, что целевой файл только что был изменен . При использовании с флагом -n показывает, что произойдет, если вы измените этот файл. Без -n это почти то же самое, что запустить команду touch для заданного файла перед запуском make, за исключением того, что время модификации изменяется только внутри make.
-- warn-undefined-variables	Предупреждать при обращении к неопределенной переменной.

Типичное использование

make обычно используется для сборки исполняемых программ и библиотек из исходного кода. Вообще говоря, make применим к любому процессу, который включает в себя выполнение произвольных команд для преобразования исходного файла в целевой результат. Например, make может использоваться для обнаружения изменений, внесенных в файл изображения (источник), а действия по преобразованию могут заключаться в преобразовании файла в определенный формат, копировании результата в систему управления контентом и последующей отправке по электронной почте. предопределенному набору пользователей, что вышеуказанные действия были выполнены.

make вызывается со списком имен целевых файлов для сборки в качестве аргументов командной строки:

Без аргументов make создает первую цель, которая появляется в ее make-файле, которая традиционно является целью с именем all.

make решает, нужно ли регенерировать цель, сравнивая время модификации файла. Это решает проблему предотвращения создания файлов, которые уже обновлены, но терпит неудачу, когда файл изменяется, но время его модификации остается в прошлом. Такие изменения могут быть вызваны восстановлением более старой версии исходного файла или когда сетевая файловая система является источником файлов, а ее часы или часовой пояс не синхронизированы с машиной, на которой выполняется make. Пользователь должен справиться с этой ситуацией, запустив полную сборку. И наоборот, если время модификации исходного файла находится в будущем, это может привести к ненужной перестройке.

Макет-файлы

make ищет в текущем каталоге make-файл для использования. GNU make ищет в файлах файл с именем GNUmakefile, makefile, а затем Makefile и запускает указанные цели из этого файла.

Язык makefile похож на декларативное программирование, в котором описываются необходимые конечные условия, но порядок выполнения действий не важен. Это может сбивать с толку программистов, привыкших к императивному программированию, которое явно описывает, как будет достигнут конечный результат.

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

Правила

Макет-файл по существу состоит из правил. Каждое правило начинается со строки зависимости, которая определяет цель, за которой следует двоеточие (":") и, возможно, перечисление компонентов (файлов или других целей), от которых зависит цель. Линия зависимости устроена так, что цель (левая часть двоеточия) зависит от компонентов (правая часть двоеточия). Обычно компоненты называют предварительными условиями цели.

Здесь символ табуляции. Обычно каждое правило имеет одну уникальную цель, а не несколько целей.

Например, объектный файл C .o создается из файлов .c, поэтому файлы .c идут первыми (т. е. конкретная цель объектного файла зависит от исходного файла C и файлов заголовков). Поскольку make сам не понимает, не распознает и не различает разные типы файлов, это открывает возможность человеческой ошибки. Забытая или дополнительная зависимость может быть не сразу очевидна и может привести к незначительным ошибкам в сгенерированном программном обеспечении. Можно написать make-файлы, которые генерируют эти зависимости, вызывая сторонние инструменты, и некоторые генераторы make-файлов, такие как набор инструментов GNU automake, могут делать это автоматически.

После каждой строки зависимости может следовать ряд командных строк, которые определяют, как преобразовать компоненты (обычно исходные файлы) в целевые (обычно «выходные данные»). Если какой-либо из компонентов был изменен, запускаются командные строки.

В GNU make первая команда может появиться в той же строке после предварительных условий, разделенных точкой с запятой:

Каждая командная строка должна начинаться с символа табуляции, чтобы ее можно было распознать как команду. Табуляция — это символ пробела, но пробел не имеет такого же специального значения. Это проблематично, так как может не быть визуальной разницы между табуляцией и набором пробелов. Этот аспект синтаксиса make-файлов часто подвергается критике, и его важно принять к сведению.

Однако GNU make (начиная с версии 3.82) позволяет пользователю выбирать любой символ (один символ) в качестве префикса рецепта, используя специальную переменную .RECIPEPREFIX, например:

Каждая команда выполняется отдельной оболочкой или экземпляром интерпретатора командной строки. Поскольку операционные системы используют разные интерпретаторы командной строки, это может привести к непереносимости make-файлов. Например, GNU make по умолчанию выполняет команды с /bin/sh, который является оболочкой, в которой обычно используются команды Unix, такие как cp.

В правиле могут не быть определены командные строки. Строка зависимости может состоять исключительно из компонентов, ссылающихся на цели, например:

Командные строки правила обычно устроены так, что они генерируют цель. Пример: если "file.html" новее, он преобразуется в текст. Содержимое make-файла:

Приведенное выше правило будет срабатывать при обновлении файла "file.txt".

В следующем вызове make обычно использует это правило для обновления цели "file.txt", если "file.html" был новее:

Командные строки могут иметь один или несколько из следующих трех префиксов:

дефис-минус (-), указывающий, что ошибки игнорируются
знак at (@), указывающий, что команда не выводится на стандартный вывод до ее выполнения
знак плюс (+), команда выполняется, даже если make вызывается в режиме "не выполнять"

Игнорирование ошибок и заглушение всего эхо-вывода также можно получить с помощью специальных целей ".IGNORE" и ".SILENT" соответственно.

Макросы

Makefile может содержать определения макросов. Макросы обычно называют переменными, если они содержат простые строковые определения, такие как «CC=clang», которые определяют clang как компилятор C. Макросы в make-файлах могут быть переопределены в аргументах командной строки, передаваемых утилите make. переменные среды также доступны в виде макросов.

Макросы позволяют пользователям указывать вызываемые программы и другое пользовательское поведение в процессе сборки. Например, как только что показано, макрос "CC" часто используется в make-файлах для ссылки на расположение компилятора C.

Новые макросы традиционно обозначаются заглавными буквами:

Макрос используется путем его расширения. Традиционно это делается путем заключения его имени внутри $(). Эквивалентная форма использует фигурные скобки, а не круглые скобки, например, $<>, который используется в операционных системах BSD.

Макросы могут состоять из команд оболочки с использованием оператора подстановки команд, обозначаемого обратными кавычками ("` `").

Содержимое определения сохраняется "как есть". Используется отложенное вычисление, означающее, что макросы обычно раскрываются только тогда, когда их раскрытия действительно необходимы, например, при использовании в командных строках правила. Например:

Общий синтаксис переопределения макросов в командной строке:

Makefiles могут получить доступ к любому из ряда предопределенных внутренних макросов с помощью "?" и "@" является наиболее распространенным.

Как сказал paxdiablo, make -f pax.mk выполнит make-файл pax.mk, если вы запустите его напрямую, набрав ./pax.mk, вы получите синтаксическую ошибку. Также вы можете просто ввести make, если имя вашего файла makefile/Makefile .

Как запустить Makefile из командной строки?

Загрузите mingw-get.
Настройте его.
Добавьте что-то вроде этого C:MinGWbin в переменные среды.
Запустите (! важно) git bash. …
Введите mingw-get в командной строке.
После ввода mingw-get установите mingw32-make .
Скопируйте и вставьте все файлы из C:MinGWbin в папку, где находится ваш Makefile. Готово!

Как открыть Makefile?

Если вы не можете правильно открыть файл MAKEFILE, попробуйте щелкнуть правой кнопкой мыши или нажать и удерживать файл. Затем нажмите «Открыть с помощью» и выберите приложение.

Как запустить файл в Unix?

Этапы написания и выполнения скрипта

Откройте терминал. Перейдите в каталог, в котором вы хотите создать скрипт.
Создайте файл с расширением . расширение ш.
Запишите сценарий в файл с помощью редактора.
Сделайте скрипт исполняемым с помощью команды chmod +x .
Запустите скрипт, используя ./.

Как запустить Cmake?

Запуск CMake из командной строки

Из командной строки cmake можно запустить как интерактивный сеанс вопросов и ответов или как неинтерактивную программу. Для запуска в интерактивном режиме просто передайте cmake опцию «-i». Это приведет к тому, что cmake попросит вас ввести значение для каждого значения в файле кеша для проекта.

Какой тип файла является Makefile?

Makefile — это текстовый файл, содержащий рецепт создания вашей программы. Обычно он находится в том же каталоге, что и исходники, и обычно называется Makefile. Каждая из этих команд должна быть отдельным правилом в make-файле.

Является ли Makefile скриптом оболочки?

поместите команду в файл, и это будет сценарий оболочки. Makefile, однако, представляет собой очень умный скрипт (во всех смыслах на своем родном языке), который компилирует сопутствующий набор исходного кода в программу.

Как создать файл отладки?

К сожалению, не существует отладчика make-файла, который мог бы проверить, как оценивается конкретное правило или расширяется переменная. Вместо этого большая часть отладки выполняется с помощью простых операторов печати и проверки make-файла.

Как запустить Makefile с другим именем?

Если вы хотите использовать нестандартное имя для вашего make-файла, вы можете указать имя make-файла с параметром ‘-f’ или ‘-file’. Аргументы ‘-f name’ или ‘-file= name’ сообщают make, что имя файла следует считать как makefile. Если вы используете более одного параметра ‘-f’ или ‘-file’, вы можете указать несколько make-файлов.

Как работает Makefile?

Makefile — это специальный файл, содержащий команды оболочки, который вы создаете и называете makefile (или Makefile, в зависимости от системы).… Makefile, который хорошо работает в одной оболочке, может не работать должным образом в другой оболочке. Makefile содержит список правил. Эти правила сообщают системе, какие команды вы хотите выполнить.

Что такое Makefile в Java?

создайте файл с именем makefile в каталоге домашних заданий с идентичным содержимым. измените макрос CLASSES, чтобы он имел имена ваших . Java-файлы; запустите «make», и если все пойдет хорошо, он должен скомпилировать все ваши исходные файлы Java, которые необходимо перестроить.

Что означает R в Linux?

-r, --recursive Читать все файлы в каждом каталоге, рекурсивно, по символическим ссылкам, только если они находятся в командной строке. Это эквивалентно опции -d recurse.

Как запустить EXE-файлы в Linux?

Запустите файл .exe, перейдя в «Приложения», затем в «Wine», а затем в «Меню программ», где вы сможете щелкнуть файл. Или откройте окно терминала и в каталоге файлов введите «Wine filename.exe», где «filename.exe» — это имя файла, который вы хотите запустить.

Что такое файл .a в Linux?

В системе Linux все является файлом, а если это не файл, то это процесс. Файл включает не только текстовые файлы, изображения и скомпилированные программы, но также включает разделы, драйверы аппаратных устройств и каталоги. Linux рассматривает все как файл. Файлы всегда чувствительны к регистру.

Читайте также: