Сделать (программное обеспечение)

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

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

Происхождение [ править ]

В настоящее время существует ряд утилит сборки, отслеживающих зависимости, но Make - одна из самых распространенных, в первую очередь из-за ее включения в Unix , начиная с PWB / UNIX 1.0, в которой были представлены различные инструменты, предназначенные для задач разработки программного обеспечения. ^[1] Первоначально он был создан Стюартом Фельдманом в апреле 1976 года в Bell Labs . ^{[2] [3] [1]} Фельдман получил награду ACM Software System Award 2003 за разработку этого широко распространенного инструмента. ^[4]

Фельдман был вдохновлен на написание Make благодаря опыту коллеги по тщетной отладке своей программы, в которой исполняемый файл случайно не обновлялся с изменениями:

Make возник в результате визита Стива Джонсона (автора yacc и т. Д.), Который ворвался в мой офис, проклиная судьбы, из-за которых он потратил все утро на отладку правильной программы (ошибка была исправлена, файл не был скомпилирован, cc *.oпоэтому не был затронут). Поскольку часть предыдущего вечера я провел, борясь с той же катастрофой в проекте, над которым работал, мне пришла в голову идея инструмента для ее решения. Все началось с продуманной идеи анализатора зависимостей, свелось к чему-то гораздо более простому и превратилось в Make the weekend. Использование еще влажных инструментов было частью культуры. Makefile - это текстовые файлы, а не двоичные файлы с магической кодировкой, потому что это был дух Unix: печатный, отлаживаемый, понятный материал.

-  Стюарт Фельдман, Искусство программирования Unix , Эрик С. Реймонд, 2003 г.

До появления Make система сборки Unix обычно состояла из зависимых от операционной системы сценариев оболочки make и install, сопровождающих исходный код своей программы. Возможность комбинировать команды для разных целей в один файл и возможность абстрагироваться от отслеживания зависимостей и обработки архивов была важным шагом в направлении современных сред сборки.

Производные [ править ]

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

• Sun DevPro Make появилась в 1986 году вместе с SunOS-3.2. С SunOS-3.2 она поставлялась как дополнительная программа; с SunOS-4.0 SunPro Make была сделана программой Make по умолчанию. ^{[5] [ необходим лучший исходный код ]} В декабре 2006 года Sun DevPro Make была сделана с открытым исходным кодом в рамках усилий по созданию Solaris с открытым исходным кодом . ^{[6] [7]}
• dmake или Distributed Make, которые поставлялись с Sun Solaris Studio в качестве Make по умолчанию, но не по умолчанию в операционной системе Solaris (SunOS). Первоначально это требовалось для сборки OpenOffice, но в 2009 ^[8] система сборки была переписана для использования GNU Make. Хотя Apache OpenOffice по- прежнему содержит смесь обеих систем сборки ^[9], гораздо более активно разрабатываемый LibreOffice сейчас использует только модернизированную «gbuild». ^[8]
• BSD Make ( pmake , ^[10] bmake ^[11] или fmake ^[12] ), который является производным от работы Адама де Бура над версией Make, способной создавать цели параллельно , и выживает с различной степенью модификации во FreeBSD , ^{[ 11]} NetBSD ^[13] и OpenBSD . ^{[14] В частности} , он имеет условные выражения и итерационные циклы, которые применяются на этапе синтаксического анализа и могут использоваться для условного и программного создания make-файла, ^[15] включая генерацию целей во время выполнения. ^{[ необходима цитата ]}
• GNU Make (сокращенно gmake ) - это стандартная реализация Make для Linux и macOS. ^[16] Он предоставляет несколько расширений по сравнению с исходной Make, например условные. Он также предоставляет множество встроенных функций, которые можно использовать для устранения необходимости в сценариях оболочки в правилах make-файла, а также для управления переменными, установленными и используемыми в make-файле. ^[17] Например, функцию foreach можно использовать для перебора списка значений, таких как имена файлов в заданном каталоге. ^[18] GNU Make требуется для сборки многих программных систем, включая GCC (начиная с версии 3.4 ^[19] ), ядро ​​Linux, ^{[20] [21]}Apache OpenOffice ^[9] LibreOffice ^[8] и Mozilla Firefox . ^[22]
• Ремейк Рокки Бернстайна ^[23] является ответвлением GNU Make и предоставляет несколько расширений по сравнению с GNU Make, такие как улучшенная отчетность о местоположении и обнаружении ошибок, отслеживание выполнения, профилирование выполнения, а также содержит отладчик.
• Nmake Гленна Фаулера ^{[24] не} имеет отношения к одноименной программе Microsoft. Его вход аналогичен Make, но несовместим. Эта программа предоставляет ярлыки и встроенные функции, которые, по словам разработчиков, уменьшают размер make-файлов в 10 раз.
• Microsoft nmake , инструмент командной строки, который обычно является частью Visual Studio . ^[25] Он поддерживает директивы препроцессора, такие как include и условные выражения, которые используют переменные, установленные в командной строке или в make-файлах. ^{[26] [27]} Правила вывода отличаются от Make; например, они могут включать пути поиска. ^[28] Инструмент Make, поставляемый с продуктами Embarcadero, имеет параметр командной строки, который «заставляет MAKE имитировать NMAKE от Microsoft». ^[29] . Qt Project «s Jom инструмент представляет собой клон NMAKE. ^[30]
• Mk заменил Make в Research Unix , начиная с версии 9. ^[31] Редизайн оригинального инструмента, выполненный программистом Bell Labs Эндрю Дж. Хьюмом, он имеет другой синтаксис. Mk стал стандартным инструментом сборки в Plan 9 , предполагаемом преемнике Bell Labs для Unix. ^[32]
• Кати - это замена Google GNU Make, используемого в сборках ОС Android . Он переводит make-файл в Ninja для более быстрой инкрементальной сборки. ^[33]

POSIX включает стандартизацию основных функций и работы утилиты Make и реализован с разной степенью полноты в версиях Make для Unix. В общем, простые make-файлы могут использоваться между различными версиями Make с разумным успехом. GNU Make, Makepp и некоторые версии BSD По умолчанию сначала ищутся файлы с именами «GNUmakefile», ^[34] «Makeppfile» ^[35] и «BSDmakefile» ^[36] соответственно, что позволяет размещать make- файлы, использующие определенные реализацией. поведение в разных местах.

Поведение [ править ]

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

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

сделать [ ЦЕЛЬ ... ]

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

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

Файлы Makefile традиционно используются для компиляции кода (* .c, * .cc, * .C и т. Д.), Но их также можно использовать для предоставления команд для автоматизации общих задач. Один из таких make-файлов вызывается из командной строки:

make # Без аргументов сначала запускается TARGET
make help  # Показать доступные TARGETS
make dist # Создать архив выпуска из текущего каталога

Makefile [ править ]

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

Язык make-файлов похож на декларативное программирование . ^{[38] [39] [40]} Этот класс языка, в котором описаны необходимые конечные условия, но порядок, в котором должны выполняться действия, не важен, иногда сбивает с толку программистов, привыкших к императивному программированию .

Одна из проблем автоматизации сборки - адаптация процесса сборки к конкретной платформе . Например, компилятор, используемый на одной платформе, может не принимать те же параметры, что и тот, который используется на другой. Make не очень хорошо справляется с этим. Эта проблема обычно решается путем создания инструкций сборки для конкретной платформы, которые, в свою очередь, обрабатываются Make. Обычными инструментами для этого процесса являются Autoconf , CMake или GYP (или более продвинутый NG ).

Make-файлы могут содержать пять типов вещей: ^[41]

1. Явное правило говорит , когда и как переделать один или несколько файлов, называемые целями правила. В нем перечислены другие файлы, от которых зависят цели, называемые предпосылками цели, а также может быть указан рецепт для использования при создании или обновлении целей.
2. Неявное правило говорит , когда и как переделать класс файлов на основе их имен. Он описывает, как цель может зависеть от файла с именем, аналогичным цели, и дает рецепт для создания или обновления такой цели.
3. Определение переменной - это строка, в которой указывается значение текстовой строки для переменной, которая может быть подставлена ​​в текст позже.
4. Директива является инструкцией для макияжа , чтобы сделать что - то особенное, читая Makefile , такие как чтение другого Makefile.
5. Строки, начинающиеся с #, используются для комментариев .

Правила [ править ]

Makefile состоит из правил . Каждое правило начинается с текстовой строки зависимости, которая определяет цель, за которой следует двоеточие (:) и, необязательно, перечисление компонентов (файлов или других целей), от которых зависит цель. Строка зависимости устроена так, что цель (левая часть двоеточия) зависит от компонентов (правая часть двоеточия). Обычно компоненты называют предпосылками цели. ^[42]

цель [цель ...]: [компонент ...] Tab ↹[команда 1] . . .Tab ↹[команда n]

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

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

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

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

цели :  предпосылки  ; команда

Например,

привет :  ; @ echo " привет "

Make может решить, с чего начать топологическую сортировку .

Каждая командная строка должна начинаться с символа табуляции, чтобы ее можно было распознать как команду. Табуляция представляет собой пробельный символ, но пробел не имеет такого особого значения. Это проблематично, поскольку между табуляцией и серией пробелов может не быть визуальной разницы. Этот аспект синтаксиса make-файлов часто подвергается критике; Эрик С. Реймонд описал ее как «одну из худших дизайнерских неудач в истории Unix» ^[43], а в The Unix-Haters Handbook говорится, что «использование вкладок в качестве части синтаксиса похоже на одну из тех ловушек в стиле панджи. Зеленые береты ». Фельдман объясняет свой выбор обходным решениемдля трудности ранней реализации, сохраненной желанием обратной совместимости с самыми первыми пользователями:

Почему вкладка в столбце 1? Як был новеньким, Лекс - новеньким. Я тоже не пробовал, поэтому решил, что это хороший повод научиться. После того, как я разозлился первым ударом по Лексу, я просто сделал кое-что простое с шаблоном новой строки-табуляции. Это сработало, так и осталось. А через несколько недель у меня было около дюжины пользователей, большинство из которых были друзьями, и я не хотел портить свою встроенную базу. Остальное, к сожалению, уже история.

-  Стюарт Фельдман ^[43]

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

.RECIPEPREFIX  : =  : all :: @echo  "символ префикса рецепта установлен на '$ (. RECIPEPREFIX)'"

Каждая команда выполняется отдельной оболочкой или экземпляром интерпретатора командной строки . Поскольку операционные системы используют разные интерпретаторы командной строки, это может привести к непереносимости make-файлов. Например, GNU Make (все POSIX Makes) по умолчанию выполняет команды с / bin / sh , где обычно используются команды Unix, такие как cp . В отличие от этого, nmake от Microsoft выполняет команды с cmd.exe, где доступны пакетные команды, такие как copy , но не обязательно cp.

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

realclean :  чистый  distclean

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

file.txt :  файл . htmllynx -dump file.html> file.txt

Вышеупомянутое правило будет срабатывать при обновлении файла "file.txt". В следующем вызове Make обычно использует это правило для обновления целевого файла «file.txt», если «file.html» был более новым.

сделать file.txt

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

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

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

NMAKE от Microsoft имеет предопределенные правила, которые можно не включать в эти make-файлы, например .c.obj $(CC)$(CFLAGS)

Макросы [ править ]

Makefile может содержать определения макросов. Макросы обычно называют переменными, если они содержат простые строковые определения, например {{{1}}}. Макросы в make-файлах могут быть переопределены аргументами командной строки, передаваемыми в утилиту Make. Переменные среды также доступны в виде макросов.

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

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

МАКРОС  = определение

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

NEW_MACRO  =  $ ( MACRO ) - $ ( Macro2 )

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

ГГГГММДД  =  ` даты `

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

ПАКЕТ  = ВЕРСИЯ пакета =  ` дата + "% Y.% m% d "  ` АРХИВ  =  $ ( ПАКЕТ ) - $ ( ВЕРСИЯ )dist : # Обратите внимание, что только теперь макросы раскрыты для интерпретации оболочки: # tar -cf package-`date + "% Y% m% d" `.tartar -cf $ ( АРХИВ ) .tar.

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

сделать МАКРОС = "значение"  [ МАКРОС = "значение" ... ] ЦЕЛЬ [ ЦЕЛЬ ... ]

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

target :  component 1 component 2 # содержит те компоненты, которые требуют внимания (т.е. они МЛАДШЕ, чем текущая TARGET). эхо  $?  # оценивает текущее имя TARGET из числа слева от двоеточия. эхо  $ @

Несколько общее расширение синтаксиса является использование + = , ? = И ! = Вместо знака равенства. Он работает как на BSD, так и на GNU. ^[45]

Правила суффиксов [ править ]

Правила суффиксов имеют «цели» с именами в форме .FROM.TOи используются для запуска действий на основе расширения файла. В командных строках суффиксных правил POSIX указывает ^[46], что внутренний макрос $<относится к первому предварительному условию и $@относится к цели. В этом примере, который преобразует любой HTML-файл в текст, токен перенаправления оболочки >является частью командной строки, а $<является макросом, относящимся к HTML-файлу:

.SUFFIXES : . txt . html# Из .html в .txt .html.txt :	lynx -dump $ <> $ @

При вызове из командной строки приведенный выше пример расширяется.

$ make -n file.txtlynx -dump file.html> file.txt

Правила паттернов [ править ]

Правила суффиксов не могут иметь собственных предпосылок. ^[47] Если они есть, они рассматриваются как обычные файлы с необычными именами, а не как суффиксные правила. GNU Make поддерживает суффиксные правила для совместимости со старыми make-файлами, но в остальном поощряет использование шаблонных правил . ^[48]

Шаблонное правило выглядит как обычное правило, за исключением того, что его цель содержит ровно один %символ в строке. Целевой объект считается шаблоном для сопоставления имен файлов: %может соответствовать любой подстроке из нуля или более символов ^{[49], в} то время как другие символы соответствуют только самим себе. Предпосылки также используются, %чтобы показать, как их имена соотносятся с целевым именем.

Приведенный выше пример правила суффикса будет выглядеть как следующее шаблонное правило:

# От% .html до% .txt % .txt :  %. html	lynx -дамп $ <> $ @

Другие элементы [ править ]

Однострочные комментарии начинаются с символа решетки (#).

Некоторые директивы в make-файлах могут включать другие make-файлы.

Продолжение строки обозначается обратной косой чертой \в конце строки.

 цель: компонент \ составная часть Tab ↹команда; \ Tab ↹команда | \ Tab ↹piped-команда

Примеры make-файлов [ править ]

Makefile:

ПАКЕТ  = пакет ВЕРСИЯ  =  ` дата " +% Y.% m% d% "  ` RELEASE_DIR  = .. RELEASE_FILE  =  $ ( ПАКЕТ ) - $ ( ВЕРСИЯ )# Обратите внимание, что переменная LOGNAME поступает из среды # в оболочках POSIX. # # target: all - Цель по умолчанию. Ничего не делает. all : echo  "Привет, $ ( LOGNAME ) , по умолчанию ничего не делать" # иногда: echo "Привет, $ {LOGNAME}, по умолчанию ничего не делать" echo  "Попробуйте 'make help'"# target: help - Показать вызываемые цели. help :	egrep "^ # target:"  [ мм ] akefile# Цель: список - источник Список файлов список : # не будет работать. Каждая команда находится в отдельной оболочке cd srcls# Правильно, продолжение той же оболочки cd src ;  \ls# target: dist - Сделать релиз. dist :	tar -cf $ ( RELEASE_DIR ) / $ ( RELEASE_FILE )  &&  \	gzip -9 $ ( RELEASE_DIR ) / $ ( RELEASE_FILE ) .tar

Ниже приведен очень простой make-файл, который по умолчанию (правило «все» указано первым) компилирует исходный файл с именем «helloworld.c» с использованием системного компилятора C, а также предоставляет «чистую» цель для удаления сгенерированных файлов, если пользователь желает начать все сначала. $@И $<являются двумя из так называемых внутренних макросов (также известные как автоматические переменные) и стоять имя цели и «неявный» источник, соответственно. В приведенном ниже примере $^расширяется до списка предварительных требований, разделенных пробелами. Есть ряд других внутренних макросов. ^{[46] [50]}

CFLAGS  ? = -Gвсе :  helloworldhelloworld :  helloworld . o # Команды начинаются с TAB, а не с пробелов $ ( CC )  $ ( LDFLAGS ) -o $ @ $ ^helloworld.o :  helloworld . c $ ( CC )  $ ( CFLAGS ) -c -o $ @ $ <чистый :  FRC $ ( RM ) helloworld helloworld.o# Эта псевдо-цель вызывает повторное создание всех целей, которые зависят от FRC #, даже если файл с именем цели существует. # Это работает с любой реализацией make в предположении, что # в текущем каталоге нет файла FRC. FRC :

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

все :  helloworldhelloworld :  helloworld . o $ ( CC )  $ ( CFLAGS )  $ ( LDFLAGS ) -o $ @ $ ^чистый :  FRC $ ( RM ) helloworld helloworld.o# Это явное суффиксное правило. Его можно опустить в системах #, которые автоматически обрабатывают такие простые правила. .co : $ ( CC )  $ ( CFLAGS ) -c $ <FRC : .SUFFIXES : . c

То, что helloworld.o зависит от helloworld.c, теперь автоматически обрабатывается Make. В таком простом примере, как проиллюстрированный здесь, это вряд ли имеет значение, но реальная сила суффиксных правил становится очевидной, когда количество исходных файлов в программном проекте начинает расти. Достаточно написать правило для шага связывания и объявить объектные файлы как предварительные условия. Затем make будет неявно определять, как создавать все объектные файлы, и искать изменения во всех исходных файлах.

Простые правила суффиксов работают хорошо, пока исходные файлы не зависят друг от друга и от других файлов, таких как файлы заголовков. Еще один способ упростить процесс сборки - использовать так называемые правила сопоставления с образцом, которые можно комбинировать с генерацией зависимостей с помощью компилятора. В качестве последнего примера, требующего компилятора gcc и GNU Make, вот общий make-файл, который компилирует все файлы C в папке в соответствующие объектные файлы, а затем связывает их с окончательным исполняемым файлом. Перед компиляцией зависимости собираются в формате, удобном для make-файла, в скрытый файл ".depend", который затем включается в make-файл. В переносимых программах следует избегать конструкций, используемых ниже.

# Generic GNUMakefile# Просто фрагмент кода для остановки выполнения под другими командами make (1), # которые не поймут эти строки ifneq (,) Для этого  make-файла  требуется  GNU  Make. endifПРОГРАММА  = Foo C_FILES  : =  $ ( групповой символ * .c ) OBJS  : =  $ ( patsubst% .c,% .o, $ ( C_FILES )) CC  = сс CFLAGS  = -Wall -pedantic LDFLAGS  = LDLIBS  = -lmвсе :  $ ( ПРОГРАММА )$ (ПРОГРАММА) : . зависеть  $ ( OBJS ) $ ( CC )  $ ( CFLAGS )  $ ( OBJS )  $ ( LDFLAGS ) -o $ ( ПРОГРАММА )  $ ( LDLIBS )зависит : . зависеть.depend :  cmd = gcc - MM - MF  зависеть от  $ ( var ) ; кошка  зависит >>. зависеть ;.depend :	@ECHO "Генерация зависимостей ..."	@ $ ( Еогеасп вар, $ ( C_FILES ) , $ ( CMD ))@rm -f зависит-include .depend# Это правила сопоставления с образцом. В дополнение к используемым здесь автоматическим переменным # в особых случаях может быть полезна переменная $ *, которая соответствует тому, что% означает #. % .o :  %. c $ ( CC )  $ ( CFLAGS ) -c $ <-o $ @% :  %. o $ ( CC )  $ ( CFLAGS ) -o $ @ $ <чистый :	rm -f .depend $ ( OBJS ).PHONY :  чистая  зависимость

См. Также [ править ]

• Список программного обеспечения для автоматизации сборки
• График зависимости

Ссылки [ править ]

Внешние ссылки [ править ]

В Викиучебнике есть книга на тему: make

• GNU Make домашняя страница
• Практические Makefile на примере
• Написание и отладка Makefile
• Цикл статей о GNU Make "Спроси мистера Маке"
• Управление проектами с помощью GNU make - 3.x-е издание
• Что не так с make?
• Что не так с GNU make?
• Рекурсивное объявление считается вредным
• Расширенная автоматическая генерация зависимостей .
• Использование NMake
• Make7 - портативная утилита make с открытым исходным кодом, написанная на Seed7.
• Предопределенные правила Microsoft NMAKE .