На главную | Поиск
Вы находитесь в Хранилище файлов Белорусской цифровой библиотеки
Интерпретатор make
Производственно-внедренческий кооператив
"И Н Т Е Р Ф Е Й С"
Диалоговая Единая Мобильная
Операционная Система
Демос/P 2.1
Интерпретатор
make
Москва
1988
АННОТАЦИЯ
Описан интерпретатор make, используемый для сборки
пакетов программ, минимизирующий число вызовов транслятора.
1. Введение
Интерпретатор make [1], наиболее часто используемый
программистами ДЕМОС, предоставляет уникальные возможности
по управлению любыми видами работ в операционной системе.
Всюду, где имеется необходимость учитывать зависимости фай-
лов и времена их создания (модификации), make оказывается
незаменимым инструментом. Интерпретатор реализует непроце-
дурный язык, который позволяет управлять группами командных
строк системы. В основу такого управления положены зависи-
мости между файлами с исходными данными и файлами, в которых
содержатся результаты. При этом предполагается любой возмож-
ный список действий над исходными файлами: компиляция, мак-
рообработка, редактирование, печать, упаковка или шифрование
и т.д. Исходной информацией для интерпретатора является
Make-программа, представлящая список определений макропере-
менных и список правил. Каждое правило включает формулировку
цели и список действий для интерпретатора shell. При выпол-
нении Make-программы интерпретатор make использует информа-
цию о связях между целями и результатами и передает на
выполнение shell списки действий, которые в данный момент
необходимо выполнить для получения заданного результата.
Таким образом, интерпретатор make позволяет записывать любой
набор действий над исходными данными, благодаря чему он
широко используется при решении прикладных и общесистемных
задач. Очень важно и то, что Make-программа становится
общесистемным стандартным описанием структуры задачи, алго-
ритма сборки и установки программного комплекса. Програм-
мист, владеющий средствами интерпретатора make, использует
следующую технологию разработки программного комплекса,
независимо от его сложности:
редактор -> make -> проверка -> редактор
При такой технологии существенно повышается производитель-
ность труда программиста,так как он освобождается от ручной
сборки программ, сокращается загрузка ЭВМ - make "следит" за
тем, чтобы при многократных компиляциях и отладках программ
"не делалолсь то, что можно не делать".
Важно отметить, что make является средством автоматиза-
ции процедур установки компонент ДЕМОС. Например, компонента
системы cat может включать следующие файлы:
выполняемый код - файл /bin/cat
текст программы - файл ./src/cmd/cat/cat.c
документацию - файл ./man/man1/cat.1
программу сборки - файл ./src/cmd/cat/Makefile
Файл ./src/cmd/cat/Makefile содержит всю необходимую для
правильной компиляции и установки в ОС компоненты cat инфор-
мацию. Особенно эффективен make для выполнения работ в
программных проектах малой и средней (до 200 файлов)
- 3 -
величин.
2. Принципы выполнения Make-программы
Интерпретатор make выполняет программу, которую будем
называть Make-программой. Make-программа содержит структуру
зависимостей файлов и действий над ними, оформленных в виде
списка правил. Выполнение действий приводит к созданию тре-
буемых файлов. Допустим, имеются файлы
a b c d e f
из которых определенным образом необходимо получить файл E.
Пусть далее известно, что над различными комбинациями исход-
ных файлов выполняются некоторые действия, а результаты
будут размещены в промежуточных файлах A, B, C и D. Расс-
мотрим граф, узлы которого - имена файлов. Дуги графа отра-
жают зависимости файлов, стрелка указывает направление пре-
образований от исходных файлов к файлам, которые необходимо
получить.
В Make-программе каждой паре (x,y) инцидентных узлов
этого графа ставится в соответствие список действий, выпол-
нение которых приведет к созданию x. Когда файл x сущест-
вует, список действий не выполняется, но только в том слу-
чае, если файл y создан (модифицирован) раньше по времени,
чем файл x. Каждой дуге графа можно поставить в соответсвие
значение функции t(x,y). Функция t(x,y) возвращает результат
в виде
/\
цель E / \
| /----\
| ||
t(E,D ) | t(E,C) ||
----------------------- ||
| | ||
цель D цель C ||
t(D,A) | t(D,B) | ||
---------------- | ||
| | | ||
цель A цель B | ||
| | t(C,e)| ||
t(A,a)| t(A,b) t(B,c)| t(B,d) t(C,d)| ||
------------ ------------ ------- ||
| | | | | | ||
| | | | | | ||
a b c d e f ||
- 4 -
x МОЛОЖЕ y - список действий не выполняется;
x СТАРЕЕ y - список действий выполняется.
Множество значений функции t(x,y) образует структуру динами-
ческих (зависящих от времени) связей между файлами. На этой
основе интерпретатор make выделяет те разделы Make-
программы, которые можно не выполнять.
Выше предполагалось, что каждый узел графа - это файл.
Существует возможность записать в Make-программe список
действий, выполнение которых не связано с созданием файла.
Поэтому в общем случае узел графа правильнее называть целью.
Пара инцидентных узлов графа образует цель и подцель. В при-
мере узел E - цель, узлы D и C - подцели цели E. Аналогично
узел D - цель, узлы A и B - подцели цели D. Наконец, узел A
- цель, узлы a и b - подцели узла A. Перечисление вида ЦЕЛЬ
- ПОДЦЕЛИ отражает обобщенную структуру алгоритма достижения
целей.
Введем понятие реконструкция файла-цели. Если файл-цель
существует и "МОЛОЖЕ" всех файлов, от которых зависит, то он
остается без изменений, иначе, если файл-цель существует и
"СТАРЕЕ" какого-либо файла, от которого зависит, он реконст-
руируется (изготавливается заново).
Приведем пример Make-программы, соответствующей приве-
денному выше графу. Программа выглядит как его линейная
запись:
E : D C # E зависит от D и C
cat D C > E # действие правила 1
D : A B # D зависит от A и B
cat A B > D # действие правила 2
A : a b # A зависит от a, b
cat a b > A # действие правила 3
B : c d # B зависит от c, d
cat c d > B # действие правила 4
C : e f # C зависит от e, f
cat e f > C # действие правила 5
clean clear:
-rm -f A B C D E
Здесь содержится 6 правил. Каждое правило включает строку
зависимостей файлов и командную строку системы. Правило
описывается просто: сначала указывается имя файла, который
- 5 -
необходимо создать (цель), затем двоеточие, затем имена фай-
лов, от которых зависит создаваемый файл (подцели), затем
строки действий. Первую строку правила назовем строкой
зависимостей. Следует обратить внимание на шестое правило:
в нем пустой список подцелей в строке зависимостей. Синтак-
сис строк действий соответствует синтаксису командных строк
shell. Первым символом строки действия в Make-программе дол-
жен быть символ табуляции (или 8 пробелов) - это обязатель-
ное условие.
Все последовательности символов, начиная от символа # и
до конца строки, являются комментарием. Пустые строки и лиш-
ние пробелы игнорируются. Если Make-программа размещена в
файле Makefile, то имя файла с Make-программой в командной
строке можно не указывать. Допустим, файл с Make-программой
называется Makefile, в рабочем каталоге имеются файлы a, b,
c и d. Файлы A, B, C и D отсутствуют, тогда по команде make
мы получим результат - файл Е и файлы A, B, C и D. Рассмот-
рим порядок выполнения Make-программы, когда эти файлы уже
существуют, т.е. при повторном выполнении команды make.
Первый шаг выполнения Make-программы:
E : D C
cat D C > E
Если файлы D и C существуют и не требуется их реконструкция,
а файл E "МОЛОЖЕ", чем файлы D и C, то make прекратит выпол-
нение программы - файл Е готов. Если требуется реконструк-
ция файлов D и/или C, то осуществляется переход к выполнению
подцелей D и/или C, затем возврат к этому правилу. Иначе,
если требуется реконструкция файла E, то выполняется дейст-
вие этого правила и make прекращает выполнение программы -
готов реконструированный файл E. Иначе, если отсутствуют
файлы D и/или C, будут выполнены подцели D и/или C в том
порядке, в котором они указаны в списке зависимостей, затем
выполняется действие этого правила и make прекратит выполне-
ние программы - готов файл E.
Второй шаг выполнения Make-программы:
D : A B
cat A B > D
Если файлы A, B и D существуют и не требуется их реконст-
рукция, то выполняется переход к следующему шагу Make-
программы (файл D уже готов). Если требуется реконструкция
файлов A и/или B, происходит переход к выполнению подцелей A
и/или C, затем возврат к этому правилу. Иначе, если требу-
ется реконструкция файла D, выполняется действие этого пра-
вила и переход к следующему шагу выполнения Make-программы.
Иначе, если отсутствуют файлы A и/или B, будут выполнены
подцели A и/или B в том порядке, в котором они указаны в
- 6 -
списке зависимостей, затем действие этого правила и переход
к выполнению первого правила Make-программы.
Третий шаг выполнения Make-программы:
A : a b
cat a b > A
Проверяется наличие файлов a и b в рабочем каталоге. При
отсутствии хотя бы одного из них выполнение программы прек-
ращается. Затем проверяется наличие файла A, если его нет
или требуется его реконструкция, выполняется действие этого
правила. Иначе осуществляется переход к выполнению второго
правила.
Четвертый шаг выполнения Make-программы:
B : c d
cat c d > B
Действия аналогичны описанным в третьем шаге, переход осу-
ществляется к выполнению второго правила.
Пятый шаг выполнения Make-программ:
C : e f
cat e f > C
Проверяется наличие файлов e и f в рабочем каталоге. При
отсутствии хотя бы одного из них выполнение программы прек-
ращается. Затем проверяется наличие файла C, если его нет
или требуется его реконструкция, выполняется действие этого
правила. Иначе осуществляется переход к выполнению первого
правила.
При вызове интерпретатора make в командной строке можно
указать имя цели. Если, например, необходимо получить файл
D, то командная строка выглядела бы так
% make D
или если необходимо получить файлы C и D, то командная
строка выглядела бы
% make C D
Таким образом, имя файла-цели в командной строке определяет
вход в Make-программу. Если задано несколько входов, то make
выполнит в указанном порядке все необходимые разделы Make-
программы. Если же вход не указан, выполняется первое пра-
вило Make-программы.
- 7 -
В шестом правиле примера цель не является файлом, это
важная особенность make. Программисту предоставляется воз-
можность записать правило, цель и/или подцели которого не
являются файлами. В таком случае цель - это имя входа в
Make-программу (или метка правила). Шестое правило исполь-
зуется в программе для удаления файлов. Следует обратить
внимание на то, что в этом правиле два имени цели (clean и
clear), поэтому в командной строке можно указывать любое имя
входа, например:
% make clean
или
% make clear
В результате выполнения будут удалены файлы A, B, C, D и E.
Все строки действий в правилах передаются на выполнение
shell следующим образом:
sh -c строка_действия
и должны нормально выполняться интерпретатором sh (код возв-
рата 0), иначе (по получении другого кода завершения
командной строки) make прекратит выполнение программы.
Существует способ обойти это условие. Обратите внимание на
действие в 6-м правиле: строка действий начинается с символа
"-", что означает не прекращать работу при неудачном выпол-
нении команды rm.
В Make-программе можно использовать макропеременные.
Механизм макроопределений и подстановок макропеременных в
Make-программе по смыслу аналогичен механизму подстановок в
shell, хотя по синтаксису несколько отличается. Рассмотрим
приведенный выше пример с использованием макропеременных.
Теперь Makefile будет выглядеть так:
- 8 -
SRC1 = a b # макроопределения
SRC2 = c d
SRC3 = e f
SRC4 = A B C D
E : D C
cat D C > E
D : A B
cat A B > D
A : $(SRC1) # A зависит от SRC1
cat $(SRC1) > A
B : $(SRC2) # B зависит от SRC2
cat $(SRC2) > B
C : $(SRC3) # C зависит от SRC3
cat $(SRC3) > C
clean clear:
-rm -f $(SRC4)
Первые строки Make-программы - строки с макроопределениями,
где каждой переменной SRC присваиваются значения. В правилах
выполняется операция подстановки значения макропеременной,
например $(SRC1). Макропеременные позволяют манипулировать
списками имен файлов при минимальных изменениях в тексте
Make-программы.
Интерпретатор make реализует механизм обработки умолча-
ний зависимостей файлов со стандартными суффиксами имен.
Например, файл с суффиксом имени .o можно получить из файлов
с суффиксами имен .c (язык программирования Си) и .s (язык
ассемблер). Рассмотрим пример. Допустим, имеются файлы a.c,
b.c, c.c и d.s, образующие программу, которую назовем pro-
gram. Файлы a.c, b.c и c.c содержат строку
# include program.h
т.е. зависят от файла program.h. Make-программа для работы с
этими файлами будет содержать 3 строки
program: a.o b.o c.o d.o
cc a.o b.o c.o d.o -o program
a.o b.o c.o: program.h
По команде make будет создан файл program. При первом
выполнении получим на экране дисплея:
- 9 -
cc -c a.c
cc -c b.c
cc -c c.c
as - -o d.o d.s
cc a.o b.o c.o d.o -o program
Обратите внимание на то, что интерпретатор определил необхо-
димые действия над исходными файлами с суффиксами имен .c и
.s, хотя имена этих файлов в Make-программе не указаны, и
правильно осуществил сборку программы. Теперь, допустим, мы
вызываем make на выполнениe второй раз после редактирования
файла program.h, при этом получим:
cc -c a.c
cc -c b.c
cc -c c.c
cc a.o b.o c.o d.o -o program
Если выполнить Make-программу после редактирования файла
b.c, то получим:
cc -c b.c
cc a.o b.o c.o d.o -o program
Наконец, если, допустим, необходимо получить файл c.o, то
можно выполнить команду
make c.o
Механизм умолчаний и обработки суффиксов спроектирован для
автоматизации программирования Make-программ; он существенно
сокращает размеры программ и количество ошибок в них.
3. Соглашения языка Make
Ниже в компактной форме приводятся основные синтакси-
ческие конструкции языка Make. В следующих параграфах по
каждой конструкции будут даны описания и примеры.
идентификатор
последовательность букв, цифр и символа "_", содержащая
шаблоны имен файлов ([...], ?, *), символы / и "."
идентификатор = значение
определение макропеременной. В правой части могут быть
макроподстановки, а также вся правая часть может быть
пустой строкой.
$(идентификатор)
${идентификатор}
$символ
- 10 -
подстановка значения макропеременной. Специальное зна-
чение символа $ можно отменить, указывая $$.
комментарий
текст, следующий за символом # и до конца строки. Спе-
циальное значение символа # отменяется, если он указан
в кавычках.
обратная наклонная черта
символ продолжения строки. Специальное значение сим-
вола \ отменяется, если он указан дважды.
пустая строка, пробелы
пробелы служат разделителями слов в командной строке,
лишние пробелы и табуляции игнорируются. Пустая строка
всюду игнорируется.
список_зависимостей
список_действий
правило в общем виде. Список_действий может быть пус-
тым.
.первый_суффикс.второй_суффикс:
список_действий
правило с указанием зависимостей суффиксов. Если в
Make-программе содержится хотя бы одно правило с суф-
фиксами, отличными от предопределенных, в нее необхо-
димо включить правило:
.SUFFIXES: список_суффиксов
список_целей :[:] список_подцелей
список_зависимостей. Список_подцелей может быть пус-
тым. Правила с одним и двумя символами двоеточия в
списке_зависимостей отличаются порядком выполнения
списка_подцелей и списка_действий.
имя_цели [имя_цели]
список_целей. Имя_цели - идентификатор. Можно исполь-
зовать символ / и точку. Имя_цели может быть именем
файла или каталога, тогда включается выполнение меха-
низма реконструкции. Имя_цели может не быть именем
файла, тогда механизм реконструкции не включается, а
имя_цели является меткой (именем правила, входа в
Make-программу).
имя_подцели [имя_подцели] [#комментарий]
список_подцелей. Имя_подцели - идентификатор. Можно
- 11 -
использовать шаблоны имен файлов "*", "?", [...], сим-
вол / и точку. Имя_подцели может быть именем файла,
для которого записано или не записано правило в Make-
программе, в этих случаях включается механизм реконст-
рукции. Имя_подцели может не быть именем файла, в этом
случае механизм реконструкции не включается, а имя_цели
является меткой (именем правила, входа в Make-
программу).
строка_действия [#комментарий]
...............
строка_действия [#комментарий]
список_действий. Любые командные строки ДЕМОС и управ-
ляющие конструкции Shell.
'табуляция'командная_строка_shell
строка_действия.
Строка_действия может быть указана в строке зависимос-
тей через символ ";". Строку_действия можно указывать в
следующих форматах:
'табуляция'командная__строка__shell 1
'табуляция'@командная_строка__shell 2
'табуляция'-командная_строка__shell 3
'табуляция'-@командная_строка_shell 4
В первом формате командная строка выводится на печать;
если код возврата после ее выполнения не 0, make прек-
ращает выполнение программы по ошибке. Во втором фор-
мате командная строка не выводится на печать; если код
возврата после ее выполнения не 0, make прекращает
выполнение программы по ошибке. В третьем формате
командная строка выводится на печать; если код возврата
после ее выполнения не 0, make игнорирует ошибку и
выполнение программы продолжается. В четвертом формате
командная строка не выводится на печать; если код возв-
рата после ее выполнения не 0, make игнорирует ошибку
и выполнение программы продолжается. Простая командная
строка (одна команда ДЕМОС с аргументами) выполняется
без порождения оболочки. Другие командные строки
выполняются sh следующим образом: sh -c
командная_строка_shell
Для сокращения обозначений предусмотрены макроперемен-
ные с предопределенными именами. В правиле без суффиксов
- 12 -
строка_действия может включать следующие предопределенные
макропеременные:
@ имя цели;
? имена файлов из списка подцелей, которые МОЛОЖЕ
файла_цели. Эти файлы участвуют в реконструкции цели.
В правиле с суффиксами строка_действия может включать
следующие предопределенные макропеременные:
* основа_имени_цели;
@ основа_имени_цели.второй_суффикс;
<< основа_имени_цели.первый_суффикс.
4. Использование макропеременных
При выполнении Make-программы значения макропеременных
устанавливаются в строках макроопределений и/или в командной
строке при запуске make на исполнение. Кроме того, сущест-
вуют макропеременные с предопределенными именами, значения
которых устанавливаются при выполнении Make-программы. К ним
относятся: макропеременная @, ее значение - имя_цели; макро-
переменная ?, ее значение - имена тех файлов_подцелей, кото-
рые МОЛОЖЕ файла_цели.
Предопределенные макропеременные "@" и "?" используются
только в списке действий правила и в каждом правиле имеют
свои значения. Определять значения макропеременных можно в
любом месте Make-программы, но не внутри правила. Интерпре-
татор make составляет список имен макропеременных и присваи-
вает им значения в процессе чтения Make-программы. Если зна-
чение макропеременной переопределяется, то ей присваивается
новое значение; если используются макроопределения с вложен-
ными макроподстановками, то значения устанавливаются с уче-
том всех присвоений в Make-программе. Если значение макро-
переменной задается в командной строке при запуске Make-
программы на исполнение, то все определения этой макропере-
менной в Make-программе игнорируются и используется значе-
ние, взятое из командной строки. Состояние ошибки порожда-
ется, если используется рекурсия при присвоении значения
макропеременным. Например,
A = $B
B = $A
приведет к аварийному завершению выполнения Make-программы.
В макроопределениях можно использовать метасимволы шаб-
лонов имен файлов shell. Допустим, рабочий каталог имеет
- 13 -
вид:
-rw-r--r-- 1 user 15658 Авг 6 16:03 1.m
-rw-r--r-- 1 user 2158 Авг 8 16:38 2.m
-rw-r--r-- 1 user 5185 Авг 9 17:38 3.m
-rw-r--r-- 1 user 4068 Июл 28 20:56 6.m
-rw-r--r-- 1 user 100 Авг 9 14:30 f2
-rw-r--r-- 1 user 66 Авг 9 17:42 f3
Пример Make-программы в Makefile :
A = *
B = f?
C = [0-9].*
aaa :
echo $A
echo $B
echo $C
После выполнения команды make -s получим на экране дисплея:
1.m 2.m 3.m 6.m f2 f3
f2 f3
1.m 2.m 3.m 6.m
В Make-программе часто бывает необходимо манипулировать име-
нами каталогов и файлов. Механизм макроподстановок предла-
гает удобные средства для этого. Пример:
A = *
B = [pg]*
C = f?r*
DIR1 = .
DIR2 = /etc
DIR3 = /usr/bin
aaa :
echo ${DIR1}/$A
echo ${DIR2}/$B
echo ${DIR3}/$C
После выполнения получим:
./1.m ./2.m ./3.m ./6.m ./f2 ./f3
/etc/getty /etc/group /etc/passwd
/usr/bin/fgrep
Рассмотрим пример, в котором демонстрируются всевозмож-
ные способы использования макропеременных. Допустим, имеется
Makefile
- 14 -
БИБЛИОТЕКА = ПОЛКА ${ДРУГОЕ}
ДРУГОЕ = Документы
Шкаф = ПОЛКА
папка = справки, копии.
СПРАВОЧНИКИ =
ЖУРНАЛЫ =
Словари = толковые, иностранных языков.
ТЕХНИЧЕСКАЯ = $(СПРАВОЧНИКИ) $(Словари)
ХУДОЖЕСТВЕННАЯ = проза, поэзия, драматургия.
t = Справка с места жительства.
x = Копия свидетельства о рождении.
файлы = d e
библиотека : ${БИБЛИОТЕКА}
echo 'Действия правила' $@
echo '$$? - список подцелей :' $?
echo '$$@ - имя цели :' $@
echo 'Техническая : ' $(ТЕХНИЧЕСКАЯ)
echo 'Худ. : ' $(ХУДОЖЕСТВЕННАЯ)
echo ' '
${Шкаф} : b c
echo 'Действия правила' $@
echo '$$? - список подцелей :' $?
echo '$$@ - имя цели :' $@
echo ' '
${ДРУГОЕ}: ${файлы}
echo 'Действия правила' $@
echo '$$? - список подцелей :' $?
echo '$$@ - имя цели :' $@
echo 'Папка : ' ${папка}
echo $t
echo $x
echo ' '
b:
c:
d:
e:
Следует обратить внимание на то, что $буква используется для
подстановки значения макропеременной, имя которой состоит из
одной буквы, а $(идентификатор) и ${идентификатор} равно-
ценны. Правила b, c, d и e включены исключительно для
демонстрации значений макропеременной "?". Теперь, если
выполнить команду make -s, получим на экране дисплея:
- 15 -
Действия правила ПОЛКА
$? - список подцелей : b c
$@ - имя цели : ПОЛКА
Действия правила Документы
$? - список подцелей : d e
$@ - имя цели : Документы
Папка : справки, копии.
Справка с места жительства.
Копия свидетельства о рождении.
Действия правила библиотека
$? - список подцелей : ПОЛКА Документы
$@ - имя цели : библиотека
Техническая :толковые, иностранных языков.
Худ. : проза, поэзия, драматургия.
В командной строке можно присвоить значение макропеременной.
После команды
make -s Словари = английский, немецкий.
получим на экране дисплея:
Действия правила ПОЛКА
$? - список подцелей : b c
$@ - имя цели : ПОЛКА
Действия правила Документы
$? - список подцелей : d e
$@ - имя цели : Документы
Папка : справки, копии.
Справка с места жительства.
Копия свидетельства о рождении.
Действия правила библиотека
$? - список подцелей : ПОЛКА Документы
$@ - имя цели : библиотека
Техническая : английский, немецкий.
Худ. : проза, поэзия, драматургия.
5. Выполнение правил в Make-программе
Существует несколько разновидностей правил:
с одним и двумя двоеточиями;
с одинаковыми именами целей;
не содержащие списка действий;
- 16 -
не содержащие списка подцелей и/или списка действий;
правила, предопределенные в интерпретаторе make, кото-
рые программист может включать в Make-программу.
Кроме того, имеются некоторые различия в выполнении
Make-программы, когда имя цели не является файлом. В общем
случае правило может содержать одно или два двоеточия в
качестве разделителей списков целей и подцелей. Порядок
выполнения в этих правилах одинаков, если в них указаны раз-
личные имена целей.
Правило выполняется следующим образом: сначала выполня-
ются правила с именами целей из списка подцелей, затем спи-
сок действий. Если в списке подцелей указано имя файла, для
которого правило не определено, то время создания (модифика-
ции) файла используется для определения необходимости
реконструкции цели. Если имя подцели не является файлом,
оно должно быть меткой правила, иначе порождается состояние
ошибки. Допустим, в Make-программе записано правило
monitor.c : monitor.h
Это означает, что файл monitor.c зависит от файла monitor.h.
Если monitor.h действительно имеется в рабочем каталоге, то
любые изменения в нем приведут к реконструкции файла
monitor.o, если файл monitor.h отстутствует, make прекращает
выполнять программу по ошибке. В Make-программе могут
встречаться случаи, когда необходимо для одной цели записать
несколько правил, тогда существенно важно, сколько двоеточий
указано в правиле. Ниже приведены схемы, в которых цифрами
показан порядок выполнения этих правил.
Порядок выполнения нескольких правил с одинаковым
именем_цели и одним двоеточием: сначала выполняются правила,
связанные со списками подцелей, затем список_действий одного
из правил. Список действий разрешается указывать только в
одном из таких правил:
имя_цели_А : список_подцелей <---| 1 |
имя_цели_А : список_подцелей <---| 2 |
список_действий <---| 4 |
имя_цели_А : список_подцелей <---| 3 |
Порядок выполнения нескольких правил с одинаковым
именем_цели и двумя двоеточиями. Список действий может быть
в каждом правиле:
- 17 -
имя_цели_А :: список_подцелей <---| 1 |
список_действий <---| 2 |
имя_цели_А :: список_подцелей <---| 3 |
список_действий <---| 4 |
имя_цели_А :: список_подцелей <---| 5 |
список_действий <---| 6 |
6. Режимы выполнения Make-программы
Интерпретатор make предоставляет ряд возможностей для
управления выполнением Make-программы. Для этой цели исполь-
зуются следующие директивы:
.SILENT - не печатать строки действий;
.IGNORE - игнорировать ошибки действий;
.DEFAULT - выполнить альтернативное действие;
.PRECIOUS - удалить недостроенный файл.
Директивы .SILENT и .IGNORE можно указывать как в Make-
программе, так и в командной строке ключами -s и -i, DEFAULT
и PRECIOUS только в Make-программе. Допустим имеется следу-
ющая Make-программа:
aa: bb
echo Действия правила $@
bb:
echo Действия правила $@
ppp # Несуществующая команда
sort e # Нет файла e
После выполнения получим сообщения:
echo Действия правила bb
Действия правила bb
ppp # Несуществующая команда
sh: ppp: не найден
*** Код ошибки 1
Конец.
Интерпретатор make прекратил работу по первой ошибке. Кроме
того, на экран дисплея выводятся строки действий. Отменить
вывод строк действий можно следующими способами:
указать ключ -s в командной строке при запуске make;
указать в Make-программе директиву SILENT;
- 18 -
начинать каждую строку действий символом @.
В первых двух случаях результат одинаков - не будут
выводиться строки действий. В третьем случае не будут выво-
диться строки действий вида
'табуляция'@строка_действий
Пример использования директивы SILENT.
aa: bb
echo Действия правила $@
bb:
echo Действия правила $@
ppp # Несуществующая команда
sort e # Нет файла e
.SILENT:
После выполнения программы получим:
Действия правила bb
sh: ppp: не найден
*** Код ошибки 1
Конец.
По любой ошибке make прекратит выполнение программы. Сущест-
вуют следующие способы игнорирования ошибок (Make-программа
продолжает выполняться):
указать ключ -i при запуске make на выполнение;
указать в Make-программе директиву IGNORE;
после символа табуляция указать символ "-".
В первом и втором случаях будут проигнорированы все
ошибки при выполнении строк действий, в третьем игнорируются
ошибки в тех строках действия, которые указаны следующим
образом:
'табуляция'-строка_действий
Пример использования директив SILENT и IGNORE. Обработка
ошибок при выполнении действий в правилах
- 19 -
aa: bb
echo Действия правила $@
bb:
echo Действия правила $@
ppp # Несуществующая команда
sort e # Нет файла e
.SILENT:
.IGNORE:
После выполнения программы получим:
Действия правила bb
sh: ppp: не найден
*** Код ошибки 1 (игнорирован)
sort: не могу открыть e
*** Код ошибки 1 (игнорирован)
Действия правила aa
Правило DEFAULT используется для указания альтернативных
действий по отсутствующему в данный момент файлу. Правило
DEFAULT позволяет записать список действий, которые будут
выполняться для всех отсутствующих файлов, поэтому требуется
определенная осторожность, например:
- 20 -
aa: bb
echo Действия правила $@
bb: a b c d
echo Действия правила $@
ppp # Несуществующая команда
sort e # Нет файла e
.SILENT:
.IGNORE:
.DEFAULT:
echo Действия правила .DEFAULT для $@
После выполнения программы получим:
Действия правила .DEFAULT для a
Действия правила .DEFAULT для b
Действия правила .DEFAULT для c
Действия правила .DEFAULT для d
Действия правила bb
sh: ppp: не найден
*** Код ошибки 1 (игнорирован)
sort: не могу открыть e
*** Код ошибки 1 (игнорирован)
Действия правила aa
Часто бывает необходимо прекратить выполнение Make-
программы. Это не приведет к фатальным последствиям, так
как сохраняется структура динамических (зависящих от вре-
мени) связей файлов. Однако, если создание некоторого файла
не завершилось и он тем не менее образовался, его желательно
удалить перед повторным запуском интерпретатора. Это можно
сделать автоматически, используя директиву PRECIOUS, напри-
мер:
aaa: file
sort file > $@
.PRECIOUS:
Если в момент синхронного исполнения Make-программы ввести
сигнал CTRL/C, файл $@ будет удален.
7. Правила с суффиксами
В Make-программе можно записать одно правило для обра-
ботки различных файлов. В этом случае это одно правило мно-
гократно выполняется для различных файлов, что существенно
сокращает размеры Make-программ, упрощает их разработку. Все
полезные свойства make при этом сохраняются. Механизм
- 21 -
выполнения таких правил строится на суффиксах имен файлов.
Допустим, из файла с именем основа.суффикс_1 необходимо
получить файл с именем основа.суффикс_2, тогда обычное пра-
вило будет выглядеть так:
основа.суффикс_2 : основа.суффикс_1
список действий
Понятно, что для группы файлов, основы имен которых раз-
личны, а первый и второй суффиксы имен одинаковы, желательно
было бы записать одно правило обработки. Например, файлы *.c
обычно преобразуются в файлы *.o одним списком действий, и,
следовательно, эти правила желательно записывать в виде
одного правила. Интерпретатор make предлагает эту возмож-
ность в правилах вида
.суффикс_1.суффикс_2:
список_действий
.SUFFIXES: .суффикс_1 .суффикс_2
Если в Make-программе записаны эти правила, интерпретатор,
получив в качестве аргумента имя файла с именем
основа.суффикс_1, выполнит указанное выше правило, и мы
получим результат - файл с именем основа.суффикс_2. Поря-
док выполнения правила с суффиксами такой же, как и в обыч-
ном правиле. Предопределенное правило SUFFIXES используется
для указания списка суффиксов, который может содержать более
двух суффиксов. Порядок суффиксов в списке роли не играет.
Естественно, для каждой пары суффиксов в Make-программе
должны быть записаны соответствующие правила. В правилах с
суффиксами используются предопределенные макропеременные:
@ - имя_результатa (основа.суффикс_2);
<< - имя_аргументa (основа.суффикс_1);
* - основа.
Рассмотрим пример. Допустим, имеются исходные файлы *.c
и *.k. Необходимо из них получить файлы *.t, а из них -
файл result. Допустим также, что файлы *.c зависят от файла
file.h (содержат строку #include file.h). Граф преобразова-
ний файлов в этом случае выглядит так:
- 22 -
result
|
.t
|
--------
| |
.c .k
Программа, реализующая этот граф, может быть следующей:
- 23 -
result: d.t a.t b.t c.t
echo 'Действия правила' $@
echo ' Значение $$@ - ' $@
echo ' Значение $$? - ' $?
touch $@
.k.t :
echo 'Действия правила .k.t :'
echo ' Значение $$* - ' $*
echo ' Значение $$@ - ' $@
echo ' Значение $$? - ' $?
echo ' Значение $$< - ' $<
touch $@
.c.t :
echo 'Действия правила .c.t :'
echo ' Значение $$* - ' $*
echo ' Значение $$@ - ' $@
echo ' Значение $$? - ' $?
echo ' Значение $$< - ' $<
touch $@
a.c b.c c.c : file.h
.SUFFIXES: .t .c .k
После выполнения команды make -rs получим:
Действия правила .k.t :
Значение $* - d
Значение $@ - d.t
Значение $? - d.k
Значение $< - d.k
Действия правила .c.t :
Значение $* - a
Значение $@ - a.t
Значение $? - file.h a.c
Значение $< - a.c
Действия правила .c.t :
Значение $* - b
Значение $@ - b.t
Значение $? - file.h b.c
Значение $< - b.c
Действия правила .c.t :
Значение $* - c
Значение $@ - c.t
Значение $? - file.h c.c
Значение $< - c.c
Действия правила result
- 24 -
Значение $@ - result
Значение $? - d.t a.t b.t c.t
Заметим, что правило .k.t выполняется только один раз, пра-
вило .c.t - три раза, как и требовалось для списка исходных
файлов, указанных в списке подцелей правила result. Смысл
макропеременной "?" в правиле с суффиксом тот же, что и в
обычном файле - список подцелей. Макропеременная "@" в обыч-
ном правиле - имя цели, а здесь имя результата - файл с име-
нем основа.суффикс_2.
Интерпретатор make содержит список правил для стандарт-
ных суффиксов имен файлов и определения самих суффиксов.
Этот список подключается к Make-программе пользователя, если
make запускается на выполнение без ключа -r. Программист
полностью освобождается от указания правил преобразований
файлов со стандартными суффиксами имен. Обрабатываются
файлы, имена которых включают следующие суффиксы:
.out - файл в загрузочном формате;
.o - объектный файл;
.c - файл на языке Си;
.f - файл на языке Фортран;
.p - файл на языке Паскаль;
.s - файл на ассемблере;
.l - файл на lex;
.y - файл на yacc;
Кроме того, в Make-программу включаются предопределенные
макропеременные:
LOADLIBES = # имена библиотек
AS = as - # имя ассемблера
CC = cc # имя Си-компилятора
CFLAGS = # ключи Си-компилятора
PC = pc # имя Паскаль-компилятора
PFLAGS = # ключи Паскаль-компилятора
FF = f77 # имя f77-компилятора
FFLAGS = # ключи f77-компилятора
LEX = lex # имя генератора
LFLAGS = # ключи lex
YACC = yacc # имя генератора
YFLAGS = # ключи yacc
Значения предопределенных макропеременных можно менять в
Make-программе, например, если ввести строку CFLAGS = -O,
то предопределенная макропеременная CFLAGS будет иметь новое
значение в Make-программe. Ниже приводятся граф зависимос-
тей целей и список правил Make-программы, реализующей обра-
ботку файлов по суффиксам имен.
- 25 -
.c .f .p .s .l .y
| | | | | |
|-------------------------
|
|
---> .out <--- .o ---
|
|
--------------------------
| | | | | |
.p .f .c .s .l .y
|
---
| |
.l .y
- 26 -
.l.out:
$(LEX) $<
$(CC) $(CFLAGS) lex.yy.c $(LOADLIBES) -ll -o $@
rm lex.yy.c
.y.out:
$(YACC) $(YFLAGS) $<
$(CC) $(CFLAGS) y.tab.c $(LOADLIBES) -ly -o $@
rm y.tab.c
.f.out:
$(FF) $(FFLAGS) $< $(LOADLIBES) -o $@
-rm $*.o
.o.out:
$(CC) $(CFLAGS) $< $(LOADLIBES) -o $@
.c.out:
$(CC) $(CFLAGS) $< $(LOADLIBES) -o $@
.p.out:
$(PC) $(PFLAGS) $< $(LOADLIBES) -o $@
.s.out:
$(CC) $(CFLAGS) $< $(LOADLIBES) -o $@
.l.c:
$(LEX) $<
mv lex.yy.c $@
.y.c:
$(YACC) $(YFLAGS) $<
mv y.tab.c $@
.l.o:
$(LEX) $(LFLAGS) $<
$(CC) $(CFLAGS) -c lex.yy.c
rm lex.yy.c; mv lex.yy.o $@
.y.o:
$(YACC) $(YFLAGS) $<
$(CC) $(CFLAGS) -c y.tab.c
rm y.tab.c; mv y.tab.o $@
.s.o:
$(AS) -o $@ $<
.f.o:
$(FF) $(FFLAGS) -c $<
.c.o:
$(CC) $(CFLAGS) -c $<
- 27 -
.p.o:
$(PC) $(PFLAGS) -c $<
.SUFFIXES: .out .o .c .f .p .y .l .s
Допустим, имеются файлы f[1-6].c с исходными текстами прог-
раммы result. Файлы f[1-3].c содержат строки
# include file1.h
# include file2.h
и файлы f[4-6].c содержат строку
# include file3.h
Следующая программа управляет созданием программы result:
CFLAGS = -O
LDFLAGS = -s -n -o
OBJS = f1.o f2.o f3.o f4.o f5.o f6.o
result: ${OBJS}
${CC} ${OBJS} ${LDFLAGS} $@
f1.o f2.o f3.o : file1.h file2.h
f4.o f5.o f6.o : file3.h
Так выглядит протокол выполнения:
cc -O -c f1.c
cc -O -c f2.c
cc -O -c f3.c
cc -O -c f4.c
cc -O -c f5.c
cc -O -c f6.c
cc f1.o f2.o f3.o f4.o f5.o f6.o -s -n -o result
Теперь изменим время модификации файла командой
touch file3.h
и снова выполним программу, в результате получим:
cc -O -c f4.c
cc -O -c f5.c
cc -O -c f6.c
cc f1.o f2.o f3.o f4.o f5.o f6.o -s -n -o result
Теперь изменим время модификации файла командой touch f3.c и
снова выполним программу
- 28 -
cc -O -c f3.c
cc f1.o f2.o f3.o f4.o f5.o f6.o -s -n -o result
Программист может отключить стандартные определения и список
правил с суффиксами (ключ -r), может их использовать наряду
с теми, что определены в Make-программе. Допустим, к имею-
щимся файлам предыдущего примера добавляются файлы a1.t,
a2.t и a3.t, их необходимо обработать программой sed, выхо-
дом которой будут файлы a1.c a2.c a3.c. Теперь Make-
программа выглядит так:
CFLAGS = -O
LDFLAGS = -o
OBJS = a1.o a2.o a3.o f1.o f2.o f3.o f4.o f5.o f6.o
result: ${OBJS}
${CC} ${OBJS} ${LDFLAGS} $@
f1.o f2.o f3.o : file1.h file2.h
f4.o f5.o f6.o : file3.h
a1.c: a1.t
a2.c: a2.t
a3.c: a3.t
.t.c:
sed s/aaa/bbb/ < $< > $*.c
.SUFFIXES: .t
Протокол выполнения программы:
sed s/aaa/bbb/ < a1.t > a1.c
cc -O -c a1.c
sed s/aaa/bbb/ < a2.t > a2.c
cc -O -c a2.c
sed s/aaa/bbb/ < a3.t > a3.c
cc -O -c a3.c
cc -O -c f1.c
cc -O -c f2.c
cc -O -c f3.c
cc -O -c f4.c
cc -O -c f5.c
cc -O -c f6.c
cc a1.o a2.o a3.o f1.o f2.o f3.o f4.o f5.o f6.o -o result
Make допускает обработку суффиксов только одного уровня вло-
женности. В правиле SUFFIXES указан только суффикс t, суф-
фикс c определен в подключаемом списке суффиксов.
- 29 -
8. Управление архивом в Make-программе
В ДЕМОС существуют два типа архивов: архив текстовых
файлов и архив объектных файлов (имеющий структуру библио-
теки объектных модулей). Созданный архив является одним
файлом, а файлы, из которых он собран, образуют его части.
Управление архивом включает две задачи: создание
файла_архива определенной структуры и его модификация
(добавление, удаление и замена частей, изменение структуры,
декомпозиция архива на файлы, из которых он был образован).
Для решения таких задач Make-программа должна обеспечивать
работу с целями двух типов: файл_архив и файл для включения
в архив. При этом оценивается время последней модификации
включаемого в архив файла (а не время создания архива или
записи файла_части в архив). Имя файла_архива может указы-
ваться в списке зависимостей правил как обычная цель:
имя_архивного_файла(имя_файла_для_включения_в_архив)
Кроме имен файлов, при работе с библиотекой объектных моду-
лей можно указывать имена функций
имя_файла_библиотеки((_внешнее_имя_библ_функции))
Рассмотрим фрагмент Make-программы для построения библиотеки
с именем libP.a:
L = libP.a
CFLAGS = -O
$(L)::
ar r $(L)
$(L):: $(L)(Ia.o) $(L)(La.o) $(L)(Da.o)
# Iabs, Labs, Dabs - имена функций
$(L)(Iabs.o): lib/Ia.c
$(CC) $(CFLAGS) lib/Ia.c
ar r $(L) Ia.o
-rm -f Ia.o
$(L)(Labs.o): lib/La.c
$(CC) $(CFLAGS) lib/La.c
ar r $(L) La.o
-rm -f La.o
$(L)(Dabs.o): lib/Da.c
$(CC) $(CFLAGS) lib/Da.c
ar r $(L) Da.o
-rm -f Da.o
У такого способа работы с библиотекой есть недостаток -
- 30 -
Make-программа должна содержать структуру библиотеки. Список
имен библиотечных модулей во втором правиле "$(L)::" соот-
ветствует порядку их размещения в библиотеке. Еще одно неу-
добство заключается в том, что если бы библиотека содержала
большое количество модулей, например 100, то потребовалась
бы запись 100 правил в программе. Для построения однопро-
ходных библиотек такой способ указания структуры имеет
существенный недостаток, так как изменение исходного текста
объектного модуля может привести к необходимости изменить
структуру библиотеки, а это, в свою очередь, приведет к
необходимости реконструировать Make-программу. Кроме того,
при построении библиотеки необходимо, чтобы все объектные
файлы были в рабочем каталоге.
Рассмотрим Make-программу, в которой эти недостатки
устранены. Возьмем в качестве примера файлы с исходными
текстами модулей объектной библиотеки mylib
m1.c m2.c m3.c m4.s m5.c m6.c m7.s
Допустим, структура однопроходной библиотеки с учетом вызо-
вов модулей должна быть такой:
m4.o m2.o m1.o m5.o m6.o m7.o m3.o
Текст Make-программы:
- 31 -
CFLAGS = -O
SRC = m1.c m2.c m3.c m4.s m5.c m6.c m7.s
LIB = mylib
${LIB}: ${SRC}
echo $? | sed s/\\.[cs]/\\.o/g > list
make `cat list`
ar cr $@ `cat list`
lorder $@ | tsort > list
-@if cmp list topology ; \
then \
rm -f `cat list` list;\
else \
ar x ${LIB}; rm $@;\
mv list topology;\
ar cr $@ `cat topology`;\
rm -f `cat topology`;\
echo Структура $@ изменилась.;\
fi
ranlib ${LIB}
echo Библиотека $@ готова.
m1.c : x.h
touch m1.c
m2.c : x.h y.h
touch m2.c
m3.c : x.h
touch m3.c
m5.c : y.h
touch m5.c
m6.c : x.h
touch m6.c
Рассмотрим простые случаи реконструкции уже существующей
библиотеки. Допустим, изменился исходный текст одного из
модулей. В этом случае достаточно на его место в библиотеке
включить новую версию объeктного файла этого модуля. Чтобы
не компилировать другие файлы библиотеки, можно использовать
предопределенную макропеременную "?" - список файлов, кото-
рые стали МОЛОЖЕ файла mylib. Как уже говорилось выше, в
каталоге нет объектных файлов. Следовательно, в Make-
программу необходимо включить предопределенные средства
обработки суффиксов, а в качестве аргумента формировать имя
цели с суффиксом o, тогда make автоматически построит новый
объектный файл этого модуля. В примере файл list использу-
ется в качестве временного рабочего файла. Строка вида
echo $? | sed s/\\.[cs]/\\.o/g > list
- 32 -
записывает в файл list список целей с суффиксом o. Редактор
sed используется в этой командной строке для замены суффик-
сов c и s на o. Таким образом, файл list содержит имена
файлов-целей, которые необходимо создать и на этой основе
реконструировать библиотеку. Это можно сделать, например,
так:
make `cat list`
В результате выполнения будут созданы нужные объектные
файлы. После этого можно включить объектные модули на свои
места в библиотеке mylib
ar rc mylib `cat list`
Если же библиотека mylib отсутствует,то она создается, если
модуль в библиотеке исходно отсутствовал, он записывается в
конец библиотеки (так работает команда ar с ключами cr).
По команде "make `cat list`" выполняться будет Makefile
(здесь срабатывает механизм умолчания имени файла с Make-
программой). Таким образом, имеет место рекурсивный вызов
Make-программы. При рекурсивном вызове в качестве имен
целей передаются имена объектных файлов, которые необходимо
получить и включить в библиотеку. В интерпретаторе make нет
средств, позволяющих менять список целей в процессе выполне-
ния Make-программы. Когда это необходимо, список целей соз-
дается в Make-программе и передается на выполнение как спи-
сок аргументов при вызове подпрограммы. Рекурсия в примере
понадобилась для того, чтобы не записывать полный список
правил для всех файлов-целей, а вызвать make с актуальным
списком аргументов.
Возможна такая реконструкция библиотеки, когда меняется
ее структура. Для этого в Make-программе используются
команды lorder и tsort. Lorder выводит список вызовов моду-
лей существующей библиотеки, а tsort сортирует этот список
таким образом, чтобы структура библиотеки была непротиворе-
чивой, т.е. однопроходный редактор связей мог бы за одно
чтение библиотечного файла найти все необходимые модули. В
Make-программу включаются действия, в которых строится
структура библиотеки во временном файле list и запоминается
в сохраняемом файле topology. Возможны следующие случаи
реконструкции библиотеки:
Реконструкция библиотеки не изменила ее структуры, в
этом случае файл topology не отличается от файла list.
Реконструкция изменила структуру библиотеки. В этом
случае файл topology отличается от файла list и требуется,
во-первых, получить верную структуру и запомнить ее в файле
topology, во-вторых, извлечь из библиотеки все объектные
модули (разобрать библиотеку и удалить файл с библиотекой),
- 33 -
затем собрать ее в соответствии с новой структурой. Разоб-
рать библиотеку можно командой
ar x mylib
В рабочем каталоге будут созданы копии объектных модулей из
библиотечного файла. Библиотечный файл при этом сохраняется.
Разобранную библиотеку можно собрать заново, используя
информацию о структуре библиотеки в файле topology и
команду:
ar rc mylib `cat topology`
В shell допускается записать if одной строкой следующим
образом:
if список_команд;\
then \
список_команд;\
else \
список_команд;\
fi
В Makefile эта конструкция записана:
-@if cmp list topology ; \
then \
rm -f `cat list` list;\
else \
ar x $(LIB); rm $@;\
mv list topology;\
ar cr $@ `cat topology`;\
rm -f `cat topology`;\
echo Структура $@ изменилась.;\
fi
Первая строка в ней выглядит так:
'табуляция'-@if cmp list topology ; \
Остальные строки имеют более 8 ведущих пробелов. Символ "-"
указан, так как в отдельных версиях shell оператор if при
нормальном завершении возвращает не 0. Символ "@" отменяет
вывод этой строки перед выполнением.
Приведенная Make-программа позволяет работать с любыми
объектными библиотеками. Для конкретной библиотеки (или
архива) нужно изменить макропеременные LIB, SRC и записать
зависимости от файлов включений. Если необходимо работать с
текстовыми архивами, то достаточно удалить строку ranlib
$@. Рассмотрим на примерах работу программы при различных
исходных условиях.
- 34 -
Библиотеки нет, структура неизвестна
make -s
cc -c m1.c
cc -c m2.c
cc -c m3.c
as - -o m4.o m4.s
cc -c m5.c
cc -c m6.c
as - -o m7.o m7.s
cmp: не могу открыть topology
Структура mylib изменилась.
Библиотека mylib готова.
Библиотека mylib имеется, структура остается без изме-
нений, модифицируется файл x.h
touch x.h
make -s
cc -c m1.c
cc -c m2.c
cc -c m3.c
cc -c m6.c
Библиотека mylib готова.
Меняется содержимое библиотечного модуля m5.c. Меня-
ется структура библиотеки: модуль m5 вызывает теперь модуль
m1
make -s
cc -c m5.c
Структура mylib изменилась.
Библиотека mylib готова.
В файле topology теперь новая структура библиотеки
m4.o m2.o m5.o m1.o m6.o m7.o m3.o
Добавляется новый модуль в библиотеку. Придется изме-
нить строку SRC в Make-программе. Имя модуля m8.c , вызы-
вает он модуль m5.c
cc -c m8.c
list topology различны: char 12, line 3
Структура mylib изменилась.
Библиотека mylib готова.
В файле topology теперь новая структура библиотеки
m4.o m2.o m8.o m5.o m1.o m6.o m7.o m3.o
- 35 -
Изменим модуль m1.c так, чтобы он вызывал модуль m2.c,
а модуль m2.c вызывал m1.c, т.е. получается зацикленная вза-
имная зависимость библиотечных модулей m1 и m2
make -s
cc -c m1.c
tsort: зацикленная зависимость
tsort: m2.o
tsort: m1.o
Структура mylib изменилась.
Библиотека mylib готова.
Команда tsort вывела сообщение об ошибке в структуре библио-
теки. Библиотека собрана, но пользоваться ею нельзя, необ-
ходимо исправить структуру модуля. Удалять файл mylib не
нужно, так как он содержит все объектные модули, которые
понадобятся для новой сборки.
9. Особенности программирования на языке Make
Всюду в примерах Make-программа размещалась в одном
Makefile. Существует возможность разместить ее в файле с
другим именем и при вызове интерпретатора make указать это
имя
make -f имя_файла
Иногда возникает необходимость использовать несколько Make-
файлов, образующих одну Make-программу, тогда при вызове
make можно указать
make -f имя_файла1 -f имя_файла2 и т.д.
Указанные файлы составят текст одной Make-программы в том
порядке, в котором они указаны в командной строке.
Внутри одной Make-программы можно вызывать make на
выполнение другой Make-программы, например:
LLL: a b c d
make -k -f имя_Make-файла $?
В том случае, если эта командная строка не может быть нор-
мально выполнена, ключ -k указывает на необходимость продол-
жить выполнение других разделов Make-программы, которые не
зависят от цели данного правила. Если в этом примере не
указать имя файла, в котором размещена Make-программа, то
автоматически будет выполняться Makefile и будет иметь место
рекурсивный вызов на выполнение одной программы.
Есть некоторые особенности при использовании макропере-
менных. Допустим, в Make-программе указана строка
- 36 -
SRC = a1.c a2.c a3.c # комментарий
Между a3.c и символом # 9 пробелов, они будут передаваться
всюду, где будет использовано значение макропеременной SRC.
Предопределенные макропеременные "<" и "*" в правилах
без суффиксов не определены, и их использование может при-
вести к непредсказуемым результатам.
Все, что указано за символом табуляция в строке дейст-
вий передается на выполнение shell. Однако идущие за симво-
лом табуляция символы "-" и "@" обрабатываются make.
Интерпретатор make оптимизирует скорость выполнения дейст-
вий. Если строка действий - простая команда системы, она
выполняется без порождения процесса shell. По этой причине,
например, такая строка вызовет состояние ошибки
'табуляция'#cat file
Действительно, как бы выполнялась строка "exec(# cat
file);" в Си-программе?
Если в списке зависимостей отсутствуют имена подцелей,
можно использовать сокращенную форму записи правила с одним
действием. Оно имеет вид:
имя_цели:[:]; одна_строка_действия [# комментарий]
символ ";" обязателен.
Особую осторожность необходимо соблюдать при указании в
Make-программе имени цели, которая не является файлом. В
этом случае программист должен учитывать, что он сознательно
исключает возможность использования этой цели при реконст-
рукциях, так как она не связана соотношениями времен созда-
ния (модификации) с другими объектами Make-программы. Это
препятствие можно обойти, создавая ЛОЖНЫЙ файл-цель, напри-
мер:
print: f1 f2 f3
print $?
touch print
.DEFAULT:
touch print
В рабочем каталоге создан пустой файл с именем print. Теперь
выводиться на печать будут только те файлы, которые требу-
ется распечатать как изменившиеся. Правило DEFAULT записано
на тот случай, когда файл print отсутствует.
Команду touch можно использовать, когда необходимо раз-
рушить динамическую структуру связей между файлами. Надо
- 37 -
учитывать, что при этом make будет реконструировать все
файлы заново.
Ниже перечислены все ключи интерпретатора make и их
действие:
-d отладочный режим, в котором выводится дополнительная
информация о выполнении Make-программы.
-f следующий параметр является именем Make-файла. По умол-
чанию ищется Makefile или makefile. Если имеются оба,
то выполняется Makefile. В командной строке можно ука-
зать несколько ключей -f и параметров.
-i режим игнорирования кодов завершения команд не равных
нулю. Эквивалентно директиве IGNORE.
-k если код завершения команды не равен нулю, прекратить
выполнение текущего правила и перейти к выполнению дру-
гих разделов, не зависящих от файла-цели этого правила.
-n вывести, но не выполнять строки действий Make-
программы.
-p вывести полную информацию о структуре Make-программы.
-q получить информацию о необходимости реконструкции цели.
Если реконструкция указанной цели не требуется, возвра-
щается -1, иначе 0.
-r отменяет предопределенную обработку правил с суффик-
сами, предопределенные макропеременные и суффиксы.
-s отменить вывод выполняемых строк. Эквивалентно дирек-
тиве SILENT.
-S прервать выполнение Make-программы при ошибочном завер-
шении какой-либо команды.
-t уничтожить сложившуюся структуру динамических (завися-
щих от времени) связей между файлами.
10. Автоматизация программирования Make-программ
Для создания новой Make-программы можно иметь файл-
шаблон, добавляя в него необходимые строки мы получим гото-
вую к использованию программу. Такой принцип реализован в
программе mkmf. Рассмотрим ее работу на примере. Пусть име-
ются исходные файлы f.h, f1.c, f2.c и f3.c, из которых необ-
ходимо получить файл a.out:
- 38 -
/*
** файл f.h
*/
# include <stdio.h>
# include <ctype.h>
# include <time.h>
/*
** файл f1.c
*/
# include f.h
main(ac, av)
int ac;
char **av;
{
f1(); f2(); f3();
printf("Результат выполнения программы example.\n");
}
f1(){
return;
}
/*
** файл f2.c
*/
# include f.h
int f2(){
return( a2());
}
# include <stat.h>
char *a2(){
return;
}
/*
** файл f3.c
*/
# include f.h
int f3(){
return( nn());
}
char *nn(){
return;
}
Пусть все эти файлы размещены в одном каталоге. Выполним
команду mkmf. В результате ее выполнения будет создан
Makefile с программой сборки файла a.out:
- 39 -
DEST = .
EXTHDRS = /usr/include/ctype.h \
/usr/include/stat.h \
/usr/include/stdio.h \
/usr/include/time.h
HDRS = f.h
LDFLAGS =
LIBS =
LINKER = cc
MAKEFILE = Makefile
OBJS = f1.o f2.o f3.o
PRINT = pr
PROGRAM = a.out
SRCS = f1.c f2.c f3.c
all: $(PROGRAM)
$(PROGRAM): $(OBJS) $(LIBS)
@echo -n "Сборка $(PROGRAM) ..."
@$(LINKER) $(LDFLAGS) $(OBJS) \
$(LIBS) -o $(PROGRAM)
@echo "готово."
clean:; @rm -f $(OBJS)
depend:; @mkmf -f $(MAKEFILE) \
PROGRAM=$(PROGRAM) DEST=$(DEST)
index:; @ctags -wx $(HDRS) $(SRCS)
install: $(PROGRAM)
@echo Установка $(PROGRAM) в $(DEST)
@install -s $(PROGRAM) $(DEST)
print:; @$(PRINT) $(HDRS) $(SRCS)
program:; $(PROGRAM)
tags: $(HDRS) $(SRCS)
@ctags $(HDRS) $(SRCS)
update: $(DEST)/$(PROGRAM)
- 40 -
$(DEST)/$(PROGRAM): $(SRCS) $(LIBS) \
$(HDRS) $(EXTHDRS)
@make -f $(MAKEFILE) \
DEST=$(DEST) install
###
f1.o: f.h /usr/include/stdio.h \
/usr/include/ctype.h \
/usr/include/time.h
f2.o: f.h /usr/include/stdio.h \
/usr/include/ctype.h \
/usr/include/time.h \
/usr/include/stat.h
f3.o: f.h /usr/include/stdio.h \
/usr/include/ctype.h \
/usr/include/time.h
Программой mkmf в качестве исходного файла-шаблона использо-
ван стандартный файл /usr/new/lib/p.Makefile, но можно ука-
зать для использования и любой другой.
Программа mkmf работает следующим образом: сначала
выбираются и вносятся в файл-шаблон имена всех исходных фай-
лов рабочего каталога, далее определяется от каких include-
файлов зависят исходные файлы, формируются правила и записы-
ваются в файл-шаблон. Для обозначения исходных файлов
используются правила с суффиксами.
Makefile можно редактировать, изменять значения макро-
переменных. При этом, если повторить вызов программы mkmf,
в нем появятся только те изменения, которые необходимы для
сборки с учетом изменений в исходных текстах.
В Makefile, полученном из стандартного файла-шаблона,
определены следующие макропеременные:
CFLAGS
ключи Си-компилятора;
DEST
каталог, в котором будет размещен результат;
EXTHDRS
перечень полных имен include-файлов;
HDRS
перечень имен include-файлов, размещенных в рабочем
каталоге;
LIBS
список объектных библиотек для сборки программы;
- 41 -
MAKEFILE
имя файла с Make-программой;
OBJS
список объектных файлов, участвующих в сборке прог-
раммы;
PROGRAM
имя программы, которую необходимо получить;
SRCS
список имен всех файлов с исходными текстами;
Значения макропеременных EXTHDRS, HDRS, OBJS, SRCS
устанавливаются программой mkmf и всегда имеют актуальные
значения. Остальные макропеременные получают при создании
Makefile значения по умолчанию, их можно изменять по своему
усмотрению.
Рассмотрим правила Make-программы, котороые можно
использовать как самостоятельные входы:
all
трансляция, сборка и запуск на выполнение полученной
программы;
clean
удаление ненужных файлов;
depend
изменение структуры Make-программы с учетом существую-
щего Makefile;
index
печать индексов функций собираемой программы;
install
трансляция, сборка и установка программы в указанный
каталог;
print
печать include-файлов и текстов программы;
tags
создание файла ./tags - ссылок программ, написанных на
языках Си, Паскаль и Фортран;
update
изменение Makefile, перегенерация, сборка и установка
программы в указанный каталог. С учетом произошедших
изменений в текстах исходных файлов будет выполнено
только то, что необходимо в данный момент времени.
- 42 -
Пусть имеются файлы f[123].c, f.h и Makefile, заменим в
нем значение макропеременной DEST на /usr/tmp и макропере-
менной PROGRAM - на example. Выполним следующую командную
строку:
% make program install clean
получим на экране сообщение
cc -c f1.c
cc -c f2.c
cc -c f3.c
Сборка example ... готово.
Результат выполнения программы example
Установка example в /usr/tmp
Выполним командную строку
% make index
получим имена функций и места их определений
a2 5 f2.c char *a2(){
f1 11 f1.c f1(){
f2 2 f2.c int f2(){
f3 2 f3.c int f3(){
main 5 f1.c main(ac, av)
nn 6 f3.c char *nn(){
Программа mkmf позволяет создавать Makefile для сборки биб-
лиотеки. Для этого используется файл-шаблон
/usr/new/lib/l.Makefile и дополнительно вводятся макропере-
менная LIBRARY (имя библиотеки) и правила extract (извлече-
ние из библиотеки всех частей в виде отдельных файлов),
library (трансляция и загрузка библиотеки).
Программист может отказаться от стандартных файлов-
шаблонов /usr/new/lib/[lp].Makefile и создать свои шаблоны в
рабочем каталоге. Файлы шаблоны должны иметь имена
l.Makefile и p.Makefile.
- 43 -
ЛИТЕРАТУРА
1. "Банахан М., Раттер Э. Введение в операционную систему
UNIX. - М.: Радио и связь, 1986." AI
2. "Баурн С. Операционная система UNIX.- М.: Мир, 1986." AN
3. "Браун П. Введение в операционную систему UNIX. - М.:
Мир, 1987." AM
4. "Готье Р. Руководство по операционной системе UNIX. -
М.: Финансы и статистика, 1985." AE
5. "Диалоговая единая мобильная операционная система ДЕМОС.
- Калинин: ЦЕНТРПРОГРАММСИСТЕМ, 1985." AK
6. "Инструментальная мобильная операционная система ИНМОС/
М.И. Беляков, А.Ю. Ливеровский, В.П. Семик и др. - М.:
Финансы и статистика, 1985." AH
7. "Керниган Б., Ритчи Д., Фьюер А. Язык программирования
Си. Задачи по языку Си. - М.: Финансы и статистика,
1985." AF
8. "Кристиан К. Введение в операционную систему UNIX. - М.:
Финансы и статистика, 1985." AJ
9. "Хенкок Л., Кригер М. Введение в программирование на
языке СИ. - М.: Радио и связь, 1986." AG
10. "Aho A. V., Kernighan Brian V. W., Weinberger Peter J.
AWK - a pattern scanning and processing language. Second
edition. UNIX Programmers manual, 42 BSD, 1980. Bell
Laboratries: Murray Hill, New Jersey, 1978." AL
11. "Feldman S. I. Make - a program maitaining computer pro-
gramms. Bell Laboratries: Murray Hill, New Jersey,
1978." AB
12. "Joy W. N. An introduction the UNIX C-shell. UNIX Pro-
grammers manual, 42 BSD, 1980. Bell Laboratries: Murray
Hill, New Jersey, 1978." AA
13. "Johnson S. C. YACC - yet another compiler-compiler.
Comp. Sci. tech. rep. N 32. Bell Laboratries: Murray
Hill, New Jersey, 1975." AD
14. "Lesk M. E. Lex - lexical analyzer generator. Comp. Sci.
tech. rep. N 39. Bell Laboratries: Murray Hill, New Jer-
sey, 1975." AC
- 44 -
СОДЕРЖАНИЕ
АННОТАЦИЯ ......................................... 2
1. Введение .......................................... 3
2. Принципы выполнения Make-программы ................ 4
3. Соглашения языка Make ............................. 10
4. Использование макропеременных ..................... 13
5. Выполнение правил в Make-программе ................ 16
6. Режимы выполнения Make-программы .................. 18
7. Правила с суффиксами .............................. 21
8. Управление архивом в Make-программе ............... 30
9. Особенности программирования на языке Make ........ 36
10. Автоматизация программирования Make-программ ...... 38
ЛИТЕРАТУРА ........................................ 44
- 45 -
Last-modified: Mon, 29 Jun 1998 14:13:47 GMT
Проект Либмонстра, партнеры БЦБ - Украинская цифровая библиотека и Либмонстр Россия
https://database.library.by