MAKEFILE И КОМПИЛЯЦИЯ ПРОГРАММЫ

Исходный текст программы

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

Запустим редактор программиста Programmers Notepad [WinAVR], его ярлык должен остаться у вас на рабочем столе. В меню редактора выберем File -> New -> C/C++ и напишем программу на языке Си.

Сохраним листинг программы в файл с именем "my_test.c" (каждый проект лучше сохранять в отдельной, специально созданной папке). Имя файла может быть любым без пробелов и иметь расширение ".c" .

Создание файла Makefile

В WinAVR исходный текст программы компилируется при помощи утилиты make.exe, которая находится в папке WinAVR\utils\bin. Make.exe контролирует генерацию исполняемых файлов из исходного кода программы. Для управления работой этой утилиты используют make-файлы. Make-файл сообщает компилятору, какие команды запускать, какие файлы компилировать и линковать, какой выходной код генерировать и т. д.

После установки WinAVR в папке WinAVR\sample можно найти шаблон с именем Makefile, который нужно скопировать в папку с проектом и уже там редактировать.

Внимание: Makefile и компилируемый файл (в нашем случае my_test.c ) должны находиться в одной папке.

Откроем Makefile в редакторе Programmers Notepad и отредактируем несколько важных для компилятора инструкций.

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

# MCU name
MCU = atmega128

Первая строка - комментарий, а во второй вместо atmega128 пишем тот микроконтроллер, который нас интересует (например, atmega8, attiny2313, attiny26).

Частота тактирования микроконтроллера в герцах определяется в строках:

# Processor frequency.
F_CPU = 8000000

Вместо 8000000 напишем 1000000, что будет составлять 1 мегагерц (1 МГц).
Должно получиться так:

# Processor frequency.
F_CPU = 1000000

Имя проекта, а соответственно и имя исходного файла с функцией main и выходные файлы с расширениями hex и cof, определяется в следующих строках:

# Target file name (without extension).
TARGET = testpp

Здесь вместо testpp пишем нужное имя проекта (в нашем случае my_test ).

# List C source files here. (C dependencies are automatically generated.)
SRC =

После знака "равно" пишем $(TARGET).c, чтобы получилось

# List C source files here. (C dependencies are automatically generated.)
SRC = $(TARGET).c

# List C++ source files here. (C dependencies are automatically generated.)
CPPSRC = main.cpp

Стираем запись после знака "равно". Должно получиться:

# List C++ source files here. (C dependencies are automatically generated.)
CPPSRC =

В разделе Optimization level проверяем уровень оптимизации. Можно оставить все как есть (s - оптимизирует выходной файл по размеру).

# Optimization level, can be [0, 1, 2, 3, s].
# 0 = turn off optimization. s = optimize for size.
# (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
OPT = s

После этого, немного ниже, ищем раздел:

В дальнейшем в курсе "Шаг за шагом" мы будем использовать упрощенный вариант программатора stk200.

AVRDUDE_PORT = com1 # programmer connected to serial device

Программатор stk200 использует параллельный порт (lpt).

Вы можете использовать более удобный шаблон Makefile. в котором часто изменяемые опции вынесены в начало файла. В простейшем случае для использования этого Makefile'а достаточно скопировать его в папку с проектом и изменить строки в разделе "ОСНОВНЫЕ ИНСТРУКЦИИ".

Кроме того, в состав пакета WinAVR входит утилита MFile. которая помогает правильно составить или отредактировать Makefile. Запустить утилиту можно через меню "Пуск -> Программы -> WinAVR -> MFile [WinAVR]"

Откройте в редакторе Programmers Notepad исходный текст программы my_test.c, в меню выберете Tools -> [WinAVR] Make All. Команда Make All выполняет компиляцию исходного кода программы и в случае отсутствия ошибок генерирует файл, который можно прошивать в микроконтроллер AVR.

Внизу, в окне "Output", должно появиться сообщение об успешной компиляции:

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

Самым главным из этих файлов для нас будет файл my_test.hex. В нем хранится шестнадцатиричный код для загрузки в память программ (Flash ROM) микроконтроллера.

В файле my_test.eep хранится шестнадцатиричный код для загрузки в энергонезависимую память данных (EEPROM).

Следует помнить, что после каждого изменения кода программа должна быть перекомпилирована, т.е. в редакторе Programmers Notepad выполнено Tools -> [WinAVR] Make All.

Если проект будет состоять из нескольких файлов и в одном из них что-то изменили, то при повторной компиляции будет компилироваться только измененный файл. Для полной перекомпиляции необходимо вначале выполнить команду Tools -> [WinAVR] Make Clean, а затем команду [WinAVR] Make All. Команда Make Clean удаляет все файлы, сгенерированные предыдущей командой Make All.

Lf181, Software Development: Поручите свою работу make!

Wilbert Berendsen - профессиональный музыкант и энтузиаст Linux. Когда-то увлекался ассемблером для Z80. Сегодня использует Linux для всей своей работы. Для разнообразия пишет заметки и поддерживает небольшой сайт на http://www.xs4all.nl/

wbsoft/. Viva open source!

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

Почти каждый пользователь Linux когда-нибудь сталкивался с make. будь то компиляция ядра или программы, инсталляция пакета и т.д. 'Make' - очень важный инструмент для разработки программного обеспечения, но не только.

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

Задача состоит в следующем - необходимо построить сайт, поддерживаемый разными людьми. Jan позаботиться о содержании, а Piet о форме.

Следовательно нам нужен такой метод построения при котором форма и содержание будут разделены. Одно из решений - брать содержание из базы данных при каждом обращении, используя PHP или Microsoft Active Server Pages. Но это не очень подходит для случая когда содержимое редко меняется.

• Структура сайта
  Jan хранит заметки - offer.html и index.html в своем домашнем каталоге. /home/jan/Docs/website/ .
  index.html - содержит пару новостей и приветствие. offer.html - what-do-I-know этой недели. Piet ответственен за формат и построение сайта. В конце концов странички оказываются в каталоге /home/piet/public_html.
• Шаблон
  Piet попросил Jan создать странички простым HTML, а о формате вывода он позаботиться сам.

Например заголовок помещается в header.html. а footer в footer.html. header.html выглядит следующим образом. а footer.html. Последовательность следующих команд unix обеспечивает построение странички, включая эти файлы и index.html, созданный Jan. О командах подробнее читайте в манах. Результат работы команд направляется в стандартный поток вывода, где и собирается в файл. То же самое можно повторить и для файла offer.html. В результате мы создали скрипт для построения вебсайта.

Теперь напишем небольшой shell-скрипт, который будет выполняться только в случае обновления index или header или footer! Так как мы используем Linux - решение должно быть изящным!

И в этот момент появляется make.

Руководство пользователя для GNU make - впечатляющий документ. Но с самого начала описание идет в сторону программирования. Попробую немного расширить смысл объяснений. Другими словами. если один из исходных файлов создан позже target - будет выполнена заданная последовательность команд. Цель этих команд - обновить результат.

Результат - это 'target', а исходные файлы - `prerequisites'. Команды выполняются, если хотя бы один `prerequisites' создан позже target ( или если target не существует ). Если все prerequisites созданы раньше или в одно время с target - команды не выполняются.

В каталоге необходимо создать файл с именем Makefile. который содержит инструкции для make. Создав такой файл - выполняем 'make' и наблюдаем работу инструмента.

Make вызывается командой

target по необходимости (если не указана - создается первая из Makefile). Make ищет Makefile в текущем каталоге.

Makefile создается в любом редакторе и выглядит примерно так: Начинаем с target, далее (:) и необходимые prerequisites. Если prerequisites слишком много - можно поставить (\\) и продолжить на следующей строке.

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

Обратите внимание: Команды начинаются с символа TAB, не с 8-ми пробелов!

Make читает Makefile и принимает решение о том, какие команды надо выполнить.

Если make вызывается без аргументов - будет построена только первая target.

Для нашего примера Makefile будет выглядеть следующим образом.

Мы определил три targets - 'all' и файлы index.html и offer.html. Единственное назначение 'all' - обеспечить наличие index.html и offer.html 'all' не является именем файла, поэтому эта target всегда будет выполняться. (Позже рассмотрим более удобный способ создания targets, которые не являются файлами).

Если header и footer обновились - обновляются обе страницы. Если Jan изменил только одну - одна и обновится. Команда 'make' выполнит всю работу!

Благодаря переменным Makefile становится намного проще. Определить их можно следующим образом: Хорошим тоном является использование заглавных букв для имен переменных. Теперь намного проще сменить каталог.

Также можно использовать другой метод для определения документов. Что произойдет, если необходимо поместить определения многих документов в один Makefile - он, по всей видимости, станет очень большим, из-за повторов. Это также можно упростить!

Применение `Pattern Rules' позволяет использовать один и тот же набор команд для разных targets.

При использовании rules немного изменяется синтаксис строки. добавляется поле pattern. Это поле - выражение, применяемое для всех targets. Знак % используется для объединения частей target-name.

Пример. После прочтения make эта строка разделится на две - вот здесь шаблон и определит какую часть target-name использовать с %.

Знак % в поле prerequisites указывает на ту часть, которая будет скопирована им.

Make представляет вышесказанное следующим образом. Знак % в шаблоне`/home/bla/% ' берет значение `target1.html ' из `/home/bla/target1.html ' - следовательно `% ' заменяется на `target1.html '.

Для нашего сайта это будет выглядеть так. Теперь осталась одна проблема. как использовать эти переменные с командами? Ведь команды немного различались для разных targets.

make определяет некоторые переменные для своих нужд. Некоторые из них мы и называем автоматическими. В качестве значений они, во время выполнения команд, содержат target и/или prerequisite.

Переменная $\ используется для хранения имени первой prerequisite, а $@ - для target.

Используя их можно написать следующим образом. Voilр! Всего одна строка для обоих файлов!

Далее приведем полностью получившийся Makefile. Картина начинает вырисовываться. Теперь при добавлении новых документов - их легко включить в Makefile, использую переменную DOCS.

Ну и теперь намного проще для человека, использующего этот Makefile - работа его теперь выглядит более наглядно.

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

Работа функции $(addprefix prefix,list) заключается в добавлении к каждому элементу из списка префикса. В нашем примере мы добавляем содержимое переменной TARGETDIR и (/).

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

В начале заметки мы говорили, что, несмотря на то, что target 'all' не создает файл 'all'(в строке нет ни одной команды) - эта target всегда строится. Но как быть, если файл с таким именем есть и он создан позже других.

Очень просто - сообщаем make название target для обязательного построения. Сделаем это следующим образом: Теперь наш Makefile выглядит следующим образом. Сохраните его и забудьте о нем! Теперь поддержка страниц осуществляется этим скриптом, помещенным возможно в crontab, и, что самое главное для нас, с разделенными формой и содержанием.

Конечно данный пример применим и для других случаев - естественно с небольшими изменениями.

Данное решение не защищено от нестандартных ситуаций - например Jan в конце своих файлов поставил </body></html> и как следствие footer, созданный Piet, не смогут отобразить многие браузеры. Применение grep, perl или tcl улучшит отображение информации - например размещение некоторых заголовков в начале страницы.

Также Jan может писать заметки не отформатированным тестом и последующее применение команды sed заменит все пустые строки на <P>: Еще один из вариантов - написание текста в LyX и обработка его командой lyx2html для преобразования в HTML. На самом деле подобных вариантов огромное количество!

Мы не приняли во внимание процесс перемещения картинок в каталог веб - его также можно автоматизировать!

В нашем примере Jan должен предоставить Piet права на чтение своего веб каталога. Такой вариант подходит как для больших огранизаций, так и для одного человека. Кроме того можно воспользоваться возможностями NFS.

Надеюсь вы теперь видите как можно упростить ежедневный рутинный труд, создав хороший Makefile!

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

Использование 'phony' targets (.PHONY: target), позволяет легко связать вместе простые функции. Примером может служить настройка ядра Linux.

make menuconfig вызывает интерактивное текстовое меню настройки. make xconfig вызывает интерактивное меню настройки на основе Tcl/Tk под X.

Эти targets ничего не делают с реальной настройкой ядра. Это просто оболочка для других функций (в данном примере функций для настройки ядра).

Представьте - у вас имеется большой набор документов, которые надо хранить, редактировать, распространять и т.д. Вы также хотите делать сводные документы из них, печатать, публиковать в веб - для всего этого всего один файл. Исходный файл (для работы с LaTeX!).

Вам необходимо создать Makefile со следующими PHONY targets: [help:] Список доступных targets в этом Makefile. [print-draft:] Печать, например в уменьшенном виде документа (используя ps-utils). [print-full:] Печать документа полностью. [ps:] Export документа в PostScript файл. [report:] Заголовок, резюме и отпрвка начальнику. [html:] Update html-версии. и т.д. и т.д. Таким образом решаются комплексные задачи с помощью Makefile.

Более подробную информацию о работе и возможностях make вы найдете в `GNU Make Manual'. Чтение его на компьютере с Linux осуществляется с помощью следующей команды. Конечно можно читать GNU Make Manual и в GNOME, и в KDE - help browsers или handy tkinfo помогут вам.

• (Dutch!) обзор Armijn Hemel книги `Managing your projects with make'.
• Google search

У каждой заметки есть страница отзывов. На этой странице вы можете оставить свой комментарий или просмотреть комментарии других читателей.

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

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

Если запустить
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)

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

Как устроен Makefile и что это такое?

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

Система make родилась в мире UNIX и постепенно переползла и на Windows вместе с портами GNU-компиляторов (gcc ). Если открыть пример готового Makefile, то он поначалу может показаться полной абракадаброй, поскольку содержимое файла подчиняется заранее заданному набору правил, которые необходимо предварительно изучить. Для простоты рассмотрим пример работы с проектом AVR и компилятором gcc.

Немного о структуре файла.

- Комментарии, как это принято в UNIX скриптах, начинаются с символа # и продолжаются до конца строки.
- Обычно в файле содержатся метки, идентифицирующие "цели" (targets. см. далее). Метка начинается с начала строки и оканчивается двоеточием. После двоеточия могут идти так называемые зависимости, dependencies (сразу непонятно, что это такое и для чего надо, но дальше по ходу дела станет яснее). Обычно это имена файлов, либо ссылки на цели.
- Если в качестве dependencies указана последовательность целей, то они будут выполняться друг за другом.
- Если в качестве dependencies указаны имена файлов (обычно объектных), то утилита make может проверить - нужно их компилировать, или нет (мне непонятно, как она проверяет, однако это работает). Например, если компилируется несколько исходных файлов в несколько объектных, то некоторые исходные файлы не требуется каждый раз перекомпилировать заново, если они не изменялись. Для больших проектов это важно, поскольку существенно экономит время сборки программы (в нашем случае - получение двоичной прошивки для AVR).
- Для упрощения содержимого Makefile и для удобства используются переменные. Пример задания переменной (здесь в переменную записана командная строка вызова программатора):

После задания переменной на неё можно ссылаться так:

- После задания в одной строке цели (цель: [зависимость1]. [зависимостьN]) в последующих строках могут задаваться так называемые правила (rules ). Каждое правило должно ОБЯЗАТЕЛЬНО начинаться с символа табуляции (таким способом make отслеживает правила и другие цели). Правило - это просто обычная команда (вызов компилятора, копирование, удаление и проч.), выполняемая шеллом.
- Переменные $@, $<. $^ называются автоматическими (automatic variables).

$@ заменяется на текущую цель.
$< которая заменяется на первую зависимость из списка.
$^ которая заменяется на список всех зависимостей с их каталогами.

Итак, при работе с проектом может потребоваться автоматизировать следующие часто повторяющиеся действия:

1. Компиляция программы (вводимая команда будет выглядеть как make hex).
2. Запись двоичного файла (make flash).
3. Запись бит "перемычек" (make fuse, для микроконтроллеров AVR это обычно 2 байта).
4. Полная запись микроконтроллера (и памяти и перемычек), выполняются действия и 2, и 3.
5. Очистка проекта - удаление всех промежуточных файлов, образующихся при компиляции, обычно объектных (make clean).
6. Стирание микроконтроллера (очистка flash и сброс перемычек в исходное состояние).
7. Бэкап проекта (make backup), будет выполняться цель 5 (clean), а затем архивирование файлов.
8. Вывод подсказки по возможным вариантам работы с проектом (просто make, при этом выводится подсказка по make hex, make flash, make fuse, make clean).

Для каждого такого действия 1..8 в Makefile прописывается блок команд, этот блок идентифицируется целью (target). Имя цели по сути является меткой, по которой переходит управление при обработке команды, переданной программе make. Для действия 1 это будет запуск компилятора (цель hex), для 2 - вызов программатора (цель flash) и т. д. Рассмотрим для примера ветку обработки цели hex (команда make hex) по шагам - см. рабочий Makefile [4] на примере проекта из библиотеки V-USB.

1. Пользователь вводит команду make hex.
2. Программа make открывает файл Makefile, ищет цель hex и начинает её обработку.
3. Для цели hex указана зависимость main.hex и ни одного правила (строка 131). Программа make ищет цель main.hex и начинает её обработку.
4. Для цели main.hex указана зависимость main.elf (строка 175) и несколько правил. Программа make ищет цель main.elf и начинает её обработку (правила цели main.hex будут отрабатываться после окончания обработки цели main.elf).
5. Для цели main.elf указаны зависимости usbdrv и $(OBJECTS) (строка 172), а также одно правило (вызов компилятора для получения файла main.elf). Программа make ищет цель usbdrv и начинает её обработку.
6. Для цели usbdrv не указано зависимостей (строка 169), только одно правило (копирование папки usbdrv в текущий каталог). Выполняется это правило, цель usbdrv завершена и происходит возврат к обработке цели main.elf.
7. Зависимости, входящие в переменную $(OBJECTS) (строка 172), не являются целями, это просто имена файлов, которые должны быть получены при компиляции. Поэтому сразу начинается выполняться правило, запускающее компилятор (строка 173). В результате те объектные файлы, которые должны быть скомпилированы, появляются в соответствующих каталогах, и появляется выходной файл main.elf (двоичный файл, который может использоваться в качестве входного для эмулятора или симулятора при отладке программы). Цель main.elf завершена, происходит возврат к обработке цели main.hex (строка 175).
8. Начинается обработка правил цели main.hex. Команда rm удаляет старые файлы прошивок flash и eeprom, avr-objcopy генерирует новую прошивку main.hex из файла main.elf, avr-size просто отображает информацию о размере секций в файле main.hex. Обработка цели main.hex закончена, происходит возврат к обработке цели hex.
9. Все зависимости цели hex обработаны, правил у цели hex нет. Работа make на этом завершается.

Есть утилиты-визарды для автоматической генерации файлов Makefile, например входящая в пакет WinAVR утилита MFile (запускается ярлычком C:\WinAVR-20080610\bin\wish84.exe mfile.tcl).

[Проблемы и их решение ]

1. Makefile в среде Windows (Makefile работает при помощи пакета MSYS) завершается с ошибкой на команде xcopy, например (выполнение команды make backup):

Проблема решается добавлением в начало Makefile строки "SHELL=cmd.exe". Вот пример рабочего Makefile, в котором эта ошибка устранена:

2. Сетевые (UNC) пути необходимо заключать в двойные кавычки, иначе они будут неправильно переданы интерпретатору cmd.exe. Вот так:

3. Отлаживать makefile удобно с помощью команды echo, выводя в консоль значения переменных. Пример:

[Как создать простейший makefile ]

Предположим, есть три файла: program.c, program.h и header.h. Нужно их скомпилировать компилятором gcc. Как это проще всего осуществить?

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

Обратите внимание, что вместо пробелов в начале строк должны быть символы табуляции, иначе makefile работать не будет. Это нужно исправить, когда будете копировать этот текст как шаблон нового makefile.

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

Это простейший пример, и для упрощения здесь опущены такие макросы, как $(CC), $(CFLAGS) и другие. Вот пример несложного makefile, который я часто использую для компилирования исходного кода на языке C.

В этом makefile используются функции wildcard и patsubst утилиты make для автоматического подключения файлов *.c и *.h в текущей директории. Это означает, что когда Вы добавляете новые модули исходного кода в корневой каталог проекта, то Вам уже не надо модифицировать содержимое makefile. Если Вы хотите поменять имя генерируемого исполняемого файла, то Вам нужно просто поменять значение переменной TARGET. Для очистки проекта нужно в корневом каталоге проекта ввести команду make clean, а для компиляции make all или просто make.

В любом случае, ИМХО, не стоит использовать Autoconf/Automake. Конечно, они хорошо работают, но если Вы к ним привыкнете, то не сможете делать самых простых вещей, и Вам будет трудно разобраться в содержимом готовых makefile, которые поставляются вместе с большинством open-source проектов.

addprefix. Функция addprefix позволяет добавить префикс с каждой строке в последовательности строк. Пример:

Утилита gccmakedep. В зависимости от количества заголовков и модулей проекта, и Ваших потребностей в разработке, рассмотрите возможность использования утилиты gccmakedep [7]. Эта программа анализирует текущий каталог, и добавляет в конец makefile зависимости от заголовков для каждого найденного файла *.c/*.cpp. Конечно, если у Вас в проекте только 2 или 3 файла, то такой функционал излишен, но если модулей и заголовков намного больше, то утилита gccmakedep может пригодиться.

1. Installing MSYS site:mingw.org .
2. Home of the MinGW and MSYS Projects site:mingw.org .
3. Перевод Makefile Mini HOWTO (make) site:opennet.ru .
4. Рабочий Makefile на примере AVR-USB (USB HID-устройство и консольная утилита для работы с ним).
5. GNU Make программа управления компиляцией site:linux.yaroslavl.ru (руководство по программе make на русском языке).
6. Эффективное использование GNU Make site:linux.org.ru .
7. gccmakedep site:x.org .