Linux make файл останов

Помогите исправить. Пару дней уже гуглю нечего не помогает.

Как исправить ошибку?

Там написано — нет каталога.

А как добавить его ?!

В прошлом треде всё сказали.

поздравляю, а нам то что?

Вот это писано конечно для генты, но в общем подходит для любого дистра если заменить слово «Portage» на «менеджер пакетов» и слово «ebuild» на «пакет».

ой, а он похоже еще и под рутом сидит

Я просто тупой. только начинаю разбиратся

зачем тебе тогда кали?

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

подскачать что написать в консоле по очереди.

никогда, запомни, НИКОГДА не спрашивай такого прямым текстом. Вот у меня руки сейчас очень чешуться чтоб «подсказать» тебе рм-рф

Тебе нужно установить пакет с заголовочными фалами (linux headers) для твоей версии ядра.

Пакет может называться linux-hraders-внрсия ядра или kernel-headers-версия ядра.

Источник

Просто о make

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

Мое упорное игнорирование make в течении долгого времени, было обусловлено удобством используемых IDE, и нежеланием разбираться в этом ‘пережитке прошлого’ (по сути — ленью). Однако, все эти надоедливые кнопочки, менюшки ит.п. атрибуты всевозможных студий, заставили меня искать альтернативу тому методу работы, который я практиковал до сих пор. Нет, я не стал гуру make, но полученных мною знаний вполне достаточно для моих небольших проектов. Данная статья предназначена для тех, кто так же как и я еще совсем недавно, желают вырваться из уютного оконного рабства в аскетичный, но свободный мир шелла.

Make- основные сведения

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

1) целями (то, что данное правило делает);
2) реквизитами (то, что необходимо для выполнения правила и получения целей);
3) командами (выполняющими данные преобразования).

В общем виде синтаксис makefile можно представить так:

То есть, правило make это ответы на три вопроса:

Несложно заметить что процессы трансляции и компиляции очень красиво ложатся на эту схему:

Простейший Makefile

Предположим, у нас имеется программа, состоящая всего из одного файла:

Для его компиляции достаточно очень простого мэйкфайла:

Данный Makefile состоит из одного правила, которое в свою очередь состоит из цели — «hello», реквизита — «main.c», и команды — «gcc -o hello main.c». Теперь, для компиляции достаточно дать команду make в рабочем каталоге. По умолчанию make станет выполнять самое первое правило, если цель выполнения не была явно указана при вызове:

Компиляция из множества исходников

Предположим, что у нас имеется программа, состоящая из 2 файлов:
main.c

Makefile, выполняющий компиляцию этой программы может выглядеть так:

Он вполне работоспособен, однако имеет один значительный недостаток: какой — раскроем далее.

Инкрементная компиляция

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

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

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

После запуска make попытается сразу получить цель hello, но для ее создания необходимы файлы main.o и hello.o, которых пока еще нет. Поэтому выполнение правила будет отложено и make станет искать правила, описывающие получение недостающих реквизитов. Как только все реквизиты будут получены, make вернется к выполнению отложенной цели. Отсюда следует, что make выполняет правила рекурсивно.

Фиктивные цели

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

Командой make производят компиляцию программы, командой make install — установку. Такой подход весьма удобен, поскольку все необходимое для сборки и развертывания приложения в целевой системе включено в один файл (забудем на время о скрипте configure). Обратите внимание на то, что в первом случае мы не указываем цель, а во втором целью является вовсе не создание файла install, а процесс установки приложения в систему. Проделывать такие фокусы нам позволяют так называемые фиктивные (phony) цели. Вот краткий список стандартных целей:

• all — является стандартной целью по умолчанию. При вызове make ее можно явно не указывать.
• clean — очистить каталог от всех файлов полученных в результате компиляции.
• install — произвести инсталляцию
• uninstall — и деинсталляцию соответственно.

Для того чтобы make не искал файлы с такими именами, их следует определить в Makefile, при помощи директивы .PHONY. Далее показан пример Makefile с целями all, clean, install и uninstall:

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

Обратите внимание на то, что в цели all не указаны команды; все что ей нужно — получить реквизит hello. Зная о рекурсивной природе make, не сложно предположить как будет работать этот скрипт. Так же следует обратить особое внимание на то, что если файл hello уже имеется (остался после предыдущей компиляции) и его реквизиты не были изменены, то команда make ничего не станет пересобирать. Это классические грабли make. Так например, изменив заголовочный файл, случайно не включенный в список реквизитов, можно получить долгие часы головной боли. Поэтому, чтобы гарантированно полностью пересобрать проект, нужно предварительно очистить рабочий каталог:

Для выполнения целей install/uninstall вам потребуются использовать sudo.

Переменные

Все те, кто знакомы с правилом DRY (Don’t repeat yourself), наверняка уже заметили неладное, а именно — наш Makefile содержит большое число повторяющихся фрагментов, что может привести к путанице при последующих попытках его расширить или изменить. В императивных языках для этих целей у нас имеются переменные и константы; make тоже располагает подобными средствами. Переменные в make представляют собой именованные строки и определяются очень просто:

Существует негласное правило, согласно которому следует именовать переменные в верхнем регистре, например:

Так мы определили список исходных файлов. Для использования значения переменной ее следует разименовать при помощи конструкции $( ); например так:

Ниже представлен мэйкфайл, использующий две переменные: TARGET — для определения имени целевой программы и PREFIX — для определения пути установки программы в систему.

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

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

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

Источник

Makefile для самых маленьких

Не очень строгий перевод материала mrbook.org/tutorials/make Мне в свое время очень не хватило подобной методички для понимания базовых вещей о make. Думаю, будет хоть кому-нибудь интересно. Хотя эта технология и отмирает, но все равно используется в очень многих проектах. Кармы на хаб «Переводы» не хватило, как только появится возможность — добавлю и туда. Добавил в Переводы. Если есть ошибки в оформлении, то прошу указать на них. Буду исправлять.

Статья будет интересная прежде всего изучающим программирование на C/C++ в UNIX-подобных системах от самых корней, без использования IDE.

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

Для практики понадобится создать микроскопический проект а-ля Hello World из четырех файлов в одном каталоге:

Все скопом можно скачать отсюда
Автор использовал язык C++, знать который совсем не обязательно, и компилятор g++ из gcc. Любой другой компилятор скорее всего тоже подойдет. Файлы слегка подправлены, чтобы собирались gcc 4.7.1

Программа make

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

Процесс сборки

Компилятор берет файлы с исходным кодом и получает из них объектные файлы. Затем линковщик берет объектные файлы и получает из них исполняемый файл. Сборка = компиляция + линковка.

Компиляция руками

Самый простой способ собрать программу:
g++ main.cpp hello.cpp factorial.cpp -o hello
Каждый раз набирать такое неудобно, поэтому будем автоматизировать.

Самый простой Мейкфайл

В нем должны быть такие части:

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

Обратите внимание, что строка с командой должна начинаться с табуляции! Сохраните это под именем Makefile-1 в каталоге с проектом и запустите сборку командой make -f Makefile-1
В первом примере цель называется all . Это цель по умолчанию для мейкфайла, которая будет выполняться, если никакая другая цель не указана явно. Также у этой цели в этом примере нет никаких зависимостей, так что make сразу приступает к выполнению нужной команды. А команда в свою очередь запускает компилятор.

Использование зависимостей

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

Это надо сохранить под именем Makefile-2 все в том же каталоге

Теперь у цели all есть только зависимость, но нет команды. В этом случае make при вызове последовательно выполнит все указанные в файле зависимости этой цели.
Еще добавилась новая цель clean . Она традиционно используется для быстрой очистки всех результатов сборки проекта. Очистка запускается так: make -f Makefile-2 clean

Использование переменных и комментариев

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

Это Makefile-3
Переменные — очень удобная штука. Для их использования надо просто присвоить им значение до момента их использования. После этого можно подставлять их значение в нужное место вот таким способом: $(VAR)

Что делать дальше

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

Источник

Make нет целей останов

В папке orbitToolsDemo лежит проект:

все собирается, запускается. однако make clean и make install не работают:

, дескать, «нет правила для сборки цели clean». Что не так?

версия make: GNU Make 3.82

версия ОС: Linux version 3.10.0-327.el7.x86_64 (builder@kbuilder.dev.centos.org) (gcc version 4.8.3 20140911 (Red Hat 4.8.3-9) (GCC) )

1 ответ 1

программа gnu/make, если ей не указан файл с правилами, пытается использовать такие имена файлов (именно в таком порядке): GNUmakefile , makefile и Makefile .

в том каталоге, где вы запускаете программу gnu/make, вероятно, и присутствует файл с одним из перечисленных выше имён.

а файл с именем mkf не используется (по умолчанию).

для того, чтобы указать конкретный файл, можно передать программе gnu/make опцию -f имя_файла . например:

su -c make install

Иногда, чтобы освободить место на диске, или при перекомпиляции требуется удалить результаты предыдущей сборки – объектные файлы (*.o), двоичные файлы программы и другие временные файлы. Для этого нужно выполнить команду:

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

Если вы хотите привести исходники программы к первоначальному состоянию, т.е. удалить не только двоичные файлы, но и config.log, Makefile и другие, созданные скриптом ./configure, введите:

Теперь для повторной сборки программы вам нужно будет снова запустить ./configure.

И наконец, чтобы отменить действие команды make install, т.е. удалить установленную программу, нужно, как нетрудно догадаться, выполнить:

Как и для make install, этой команде могут потребоваться права root.

Иногда при запуске make вы можете получить такие сообщения об ошибке:

make: *** Не заданы цели и не найден make-файл. Останов.

make: *** Нет правила для сборки цели ‘uninstall’. Останов.

Это связано с тем, что при запуске утилита make ищет в текущем каталоге файл с именем Makefile или makefile (различный регистр символов). Если его нет, выдается первое сообщение. Что делать в таком случае? В первую очередь проверьте, не забыли ли вы запустить скрипт ./configure, ведь именно он создает Makefile. Если при выполнении ./configure произошла ошибка, Makefile не будет создан! Во-вторых, проверьте, нет ли в каталоге с исходниками какого-то другого подобного файла:

Например, вы можете получить список файлов типа Makefile.linux, Makefile.hpux, Makefile.macosx. Это значит, что для компиляции одной и той же программы на разных платформах автор предусмотрел несколько вариантов Makefile. Другой вариант – если вы загрузили исходный код из CVS, файл будет назван Makefile.cvs. Учтите, что Makefile.in и Makefile.am не относятся к Makefile, это всего лишь заготовки для создания Makefile. Итак, если вы нашли нужный Makefile, запустите make с ключом -f, например, так:

make -f Makefile.cvs

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

АНТОН ИВАНОВ

Работа с утилитой make

В статье на конкретных примерах рассматриваются варианты применения утилиты make как пользователями, так и разработчиками.

make для пользователей

Начнём с самого начала. Самое главное, но далеко не последнее применение утилиты make – это автоматическая сборка (компиляция) программ. И хотя большинство программ для Linux могут быть получены в двоичном (то есть в скомпилированном виде, в пакетах .deb, .tgz или .rpm), в процессе работы с Linux вам наверняка потребуется собрать программу самостоятельно из исходного кода.

Итак, вы загрузили архив с исходниками программы, скорее всего в виде tarball, т.е. сжатого tar-архива. Распространены две программы сжатия: gzip и bzip2 (последняя сжимает файлы лучше, но медленнее). Имена файлов таких архивов оканчиваются соответственно на .tar.gz (или .tgz) и tar.bz2 (или .tbz). Распакуйте архив командой:

tar xzvf имя_файла.tar.gz

tar xjvf имя_файла.tar.bz2

Другой вид распространения исходных кодов – в пакетах .src.rpm, в этом случае просто установите такой пакет как обычно, и исходники появятся в каталоге /usr/src/RPM/SOURCES.

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

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

Когда управление будет возвращено оболочке, т.е. появится приглашение ввода команд, внимательно просмотрите последние несколько строк, выведенных командой make. Если среди них есть «Error», или «Ошибка», это значит, что программа не скомпилировалась. Это может быть вызвано множеством причин: отсутствием каких-либо пакетов, ошибкой в программе, отсутствием прав записи в какой-либо файл или каталог и т. д. Еще раз внимательно перечитайте файлы README и INSTALL в каталоге с исходниками программы.

Обратите внимание, что в процессе компиляции может появляться множество предупреждений («warnings»). Они обычно вызываются небольшими несоответствиями стандарту Cи; скорее всего, они не приведут к ошибке компиляции.

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

На экран будет выведен код возврата программы. Он показывает, успешно ли завершилось выполнение программы. Если он равен нулю, то всё нормально, если отличен от нуля – произошла ошибка.

После команды make можно указывать цели сборки. Цель – это то, что нужно сделать программе make. В большинстве случаев, если цель не указана, то происходит сборка программы. Если выполнить команду:

то произойдет установка программы. Обратите внимание, что при выполнении этой команды файлы скорее всего будут скопированы в каталоги, в которые доступ на запись для простых пользователей закрыт. Поэтому вам нужно либо получить права суперпользователя (вы ведь не работаете постоянно под root, правда?), либо использовать программу su:

su -c make install

Иногда, чтобы освободить место на диске, или при перекомпиляции требуется удалить результаты предыдущей сборки – объектные файлы (*.o), двоичные файлы программы и другие временные файлы. Для этого нужно выполнить команду:

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

Если вы хотите привести исходники программы к первоначальному состоянию, т.е. удалить не только двоичные файлы, но и config.log, Makefile и другие, созданные скриптом ./configure, введите:

Теперь для повторной сборки программы вам нужно будет снова запустить ./configure.

И наконец, чтобы отменить действие команды make install, т.е. удалить установленную программу, нужно, как нетрудно догадаться, выполнить:

Как и для make install, этой команде могут потребоваться права root.

Иногда при запуске make вы можете получить такие сообщения об ошибке:

Это связано с тем, что при запуске утилита make ищет в текущем каталоге файл с именем Makefile или makefile (различный регистр символов). Если его нет, выдается первое сообщение. Что делать в таком случае? В первую очередь проверьте, не забыли ли вы запустить скрипт ./configure, ведь именно он создает Makefile. Если при выполнении ./configure произошла ошибка, Makefile не будет создан! Во-вторых, проверьте, нет ли в каталоге с исходниками какого-то другого подобного файла:

Например, вы можете получить список файлов типа Makefile.linux, Makefile.hpux, Makefile.macosx. Это значит, что для компиляции одной и той же программы на разных платформах автор предусмотрел несколько вариантов Makefile. Другой вариант – если вы загрузили исходный код из CVS, файл будет назван Makefile.cvs. Учтите, что Makefile.in и Makefile.am не относятся к Makefile, это всего лишь заготовки для создания Makefile. Итак, если вы нашли нужный Makefile, запустите make с ключом -f, например, так:

make -f Makefile.cvs

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

Вы начали компилировать программу, но вдруг. Ошибка 1. Что делать? Для начала еще раз перечитайте документацию к программе. Если ситуация не прояснилась, попробуйте запустить make с ключом -i, означающим «игнорировать все ошибки»:

Вероятность того, что программа соберется правильно, все-таки есть, особенно, если ошибка была при обработке несущественных файлов, таких как файлы документации. Если же ничего не вышло – попробуйте задать вопрос на каком-нибудь форуме, например, на linux.org.ru.

Теперь давайте заглянем внутрь Makefile. Попробуем его немного поизменять. Откройте в своем любимом текстовом редакторе, например, Makefile из исходного кода Linux (если у вас установлены исходники Linux, то это /usr/src/linux/Makefile). Посмотрите на самые первые строчки:

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

и пересобрав ядро, вы можете потом хвастаться перед друзьями командой uname -r, которая будет показывать доставшуюся вам сверхсекретную версию ядра (3.0.0.topsecret).

Если же говорить о практическом применении, то иногда вам может потребоваться немного изменить Makefile, скажем, для того, чтобы исключить компиляцию какой-либо программы из большого пакета утилит. Пример: вы загрузили свежую версию утилит KDE (пакет kdeutils). Но какая-то программа из этого пакета никак не компилируется, и make -i не помогает. Допустим, программой, на которой происходит ошибка, является kedit. Откройте kdeutils/Makefile. Теперь просто найдите все встречающиеся слова «kedit» (в редакторе vim для этого введите /kedit) и удалите их:

TOPSUBDIRS = kdf kedit kfloppy

Это список подкаталогов с исходным кодом различных программ. Утилита make по очереди заходит в каждый из них и выполняет Makefile, находящийся в этом подкаталоге. Удалите слово kedit, сохраните файл и снова запустите make. Вы увидите, что сборка kedit будет пропущена.

make для разработчиков

Пока ваша программа состоит из одного файла, проще всего компилировать ее командой:

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

Для примера создадим простую программу на C, вычисляющую квадрат числа. Она будет состоять из двух файлов: главного (main.c) и kvadrat.c, содержащего функцию возведения в квадрат. Ниже приведен исходный код этой программы:

printf(«Program calculates the square of a number. «);

printf(«Please enter an integer: «);

printf(«%d x %d = %d «, a, a, rslt);

return number * number;

Заранее скажу, что и эту программу можно скомпилировать довольно быстро без помощи Makefile командой cc *.c. Но мы все будем делать «по-правильному».

Сборка программы у нас будет разбита на два этапа: препроцессинг и компиляция, т.е. преобразование исходного кода в объектный код (файлы *.o), и сборка и линковка, т.е. объединение .o-файлов в один исполняемый файл и подключение динамических библиотек. Первый этап выполняется командой «gcc -c -o», второй – «gcc -o». gcc при запуске пытается осуществить все этапы сборки программы; параметр -c означает, что нужно только получить объектные файлы.

Итак, как вы уже знаете, утилита make ищет файл с именем Makefile. Создайте его.

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

цель: зависимость_1 зависимость_2 зависимость_N

Давайте рассуждать логически. Нам требуется собрать программу, пусть имя ее исполняемого файла будет «kv». У нас два файла с исходным кодом, каждый из них должен быть преобразован в .o-файл (принято называть объектные файлы так же, как и исходные файлы, но с расширением .o; в нашем случае это будут main.o и kvadrat.o). Именно они необходимы для сборки исполняемого файла, значит, они являются зависимостями. Ну а про команды уже было сказано выше. Итак, Makefile должен выглядеть так:

kv: main.o kvadrat.o

cc -o kv main.o kvadrat.o

cc -c -o main.o main.c

cc -c -o kvadrat.o kvadrat.c

Здесь нужно обратить внимание на несколько особенностей:

• параметр -o у cc указывает имя файла, получаемого в результате операции;
• в качестве зависимостей у целей main.o и kvadrat.o указаны соответствующие им файлы исходного кода, но это вовсе не обязательно делать. Если, скажем, файл main.c будет отсутствовать, cc и так выведет сообщение об этом. Но главная причина, по которой вам не нужно лениться и всегда указывать эту зависимость, описана чуть ниже;
• при сборке конечной цели вызывается не только cc, но и программа strip. Она позволяет зачастую значительно сократить размер выполняемого файла, удалив из него отладочную информацию.

Для понятности я опишу логику работы утилиты make с этим Makefile: сначала проверяется наличие файла main.o – первой зависимости у цели kv. Если его нет, то выполняется его компиляция, если есть, то проверяется, не был ли изменен файл main.c с момента последней его компиляции (вот зачем нужно указывать main.c как зависимость для main.o!). Если он был изменен, он компилируется заново. Если же он не был изменен, то просто пропускается; таким образом при повторной сборке можно значительно сократить затрачиваемое время.

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

Итак, сохраните Makefile и запустите make. Должны появиться два .o-файла и сам исполняемый файл kv. Для проверки запустите его:

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

Сохранив Makefile, введите make clean. Все три двоичных файла будут удалены.

Теперь создадим последнюю цель – install. Она будет служить для копирования двоичного файла программы в системный каталог.

Тут есть несколько вариантов. Во-первых, можно сделать так, чтобы при выполнении make install проверялось, была ли уже скомпилирована программа, и если нет, то перед установкой выполнялась бы ее компиляция (логично, не правда ли?). Это можно сделать, указав kv в качестве зависимости. Во-вторых, для копирования программы в системный каталог можно использовать или традиционный метод – утилиту cp, а можно – специально предназначенную для этого программу install. Она может при установке заодно изменять права доступа к программе, удалять из нее отладочную информацию (но мы это уже предусмотрели при помощи команды strip); нам же понадобится такая возможность, как автоматическое создание каталогов по указанному пути. Возможно, это звучит запутанно, так что я поясню. Мы установим программу в каталог /opt/kv/ (каталог /opt предназначен для хранения пользовательских программ, необязательных для функционирования системы). Разумеется, этого каталога еще не существует, поэтому, если бы мы использовали для установки команду «cp kv /opt/kv/», это привело бы к ошибке. Если же использовать команду install с ключом -D, она автоматически создаст все отстутствующие каталоги. Кроме того, нам нужно будет сделать так, чтобы никто, кроме root, не мог выполнять программу, а смог только считывать ее файл (права доступа r-xr—r—, или 544 в восьмеричном виде).

Добавьте в конец Makefile следующие строки:

install -D -m 544 kv /opt/kv/kv

Запустите make install, затем введите команду:

чтобы убедиться в правильности установки.

После параметра -m у команды install указываются права доступа, предпоследним параметром – файл, который нужно скопировать, последним параметром является каталог назначения с именем файла (т.е. исполняемый файл можно установить под другим именем, введя, например, /opt/kv/program_name в качестве последнего параметра).

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

install /opt/kv/file2 и т.д.

Но вдруг вам потребовалось изменить путь установки. Вам придется поменять параметр у каждой команды. И хотя это можно сделать относительно быстро при помощи команды «заменить» в текстовом редакторе, проще всего определить переменную один раз в начале Makefile и потом использовать ее (при необходимости изменяя только ее значение). Добавьте в начало Makefile определение переменной:

И затем измените команду install таким образом:

install -D -m 544 kv $(INSTALL_PATH)/kv

На что здесь нужно обратить внимание:

• в объявлении переменной указывается просто ее имя, а когда вы ее используете – знак $ и имя;
• если имя переменной состоит более чем из одного символа, при ее использовании нужно заключать такое имя в скобки;
• нужно или нет ставить косую черту в значении переменной (/opt/kv/ или /opt/kv)? Ответ: лучше перестраховаться и поставить. Как вы можете заметить, в команде установки косая черта идет подряд дважды: /opt/kv//kv (одна косая черта из значения переменной, другая – из записи $(INSTALL_PATH)/kv). Это не приведет к ошибке – вы можете поставить символ «/» хоть десять раз подряд. А вот если забудете поставить ее хотя бы один раз, то результаты, ясное дело, будут отличаться от ожидаемых.

Теперь рассмотрим такой момент: допустим, нужно выполнить некоторую команду и присвоить переменной выводимое этой командой значение. Например, если для разных версий ядра Linux существуют разные версии вашей программы. В таком случае при выполнении установки программы на системе с ядром 2.6.1 можно установить ее в каталог /opt/kv/2.6.1/, а если система запущена с ядром 2.4.24 – в каталог /opt/kv/2.4.24/. Версию ядра можно определить при помощи команды uname -r (попробуйте выполнить ее, чтобы посмотреть вашу версию ядра). Вопрос в том, как же передать полученное значение переменной? Очень просто:

INSTALL_PATH = /opt/kv/`uname -r`/

Теперь установка будет производиться в каталог /opt/kv/версия_вашего_ядра/. Обратите внимание на косые кавычки: они вводятся при помощи Shift+

(крайняя левая клавиша в ряду кнопок с цифрами).

И последнее: а ведь make может использоваться не только для компиляции программ! Например, можно использовать Makefile для сборки документации, да и вообще для автоматизации любой работы. Для примера можно создать программу, которая по команде make автоматически определяет, какие из трех файлов с именами «1», «2», «3» изменились, и при необходимости выполняет их резервное копирование в каталог backup, а по окончании работы выводит сообщение «Backup completed»:

backup: backup/1 backup/2 backup/3

Домашнее задание для вас: разберитесь, как работает этот пример, а к первому добавьте цель uninstall, так, чтобы при выполнении команды make uninstall установленная программа удалялась.

Если вас заинтересовала эта тема, прочитайте руководства «man install», «man make», а также GNU Make Manual по адресу http://www.gnu.org/software/make/manual/html_mono/make.html.gz (150 Кб). И главное – больше экспериментируйте!

Комментарии могут оставлять только зарегистрированные пользователи

Источник