MAKE                                                       MAKE
                        СОДЕРЖАНИЕ
1. Введение  2
2. Основные возможности  4
3. Файлы описаний и подстановки  9
3.1. Комментарии  9
3.2. Строки продолжения  9
3.3. Макроопределения  9
3.4. Общий вид файла описаний  9
3.5. Информация о зависимостях  10
3.6. Исполняемые команды  10
3.7. Усовершенствования $*, $@, $<  11
3.8. Выходные преобразования макросов  11
4. Рекурсивные make-файлы  13
4.1. Суффиксы и правила трансформации  13
4.2. Подразумеваемые правила  13
4.3. Архивные библиотеки  15
5. Имена SCCS-файлов (тильда)  18                              
5.1. Пустой суффикс  19
5.2. Включаемые файлы  20
5.3. make-файлы в рамках SCCS  20 
5.4. Динамические параметры зависимостей  20
              
6. Запуск утилиты make  22
6.1. Командная строка  22 
6.2. Переменные окружения  23
                                  
7. Советы и предостережения  25
                          
8. Встроенные правила  26
        1. ВВЕДЕНИЕ             
                                  
Стремление  к  увеличению модульности программ может привести к
тому, что реализация проекта будет состоять из  большого  числа
файлов.  Для формирования из них конечного продукта - программы
- могут понадобиться разнообразные порождающие процедуры.
                             
Утилита make позволяет  поддерживать  свежие  версии  программ,
состоящих из нескольких файлов, с возможностью порождения прог-
рамм различными способами.  
Всякий программист запросто может забыть:
                       
        Зависимости между файлами.
                                 
        Перечень  модифицированных файлов и воздействие модифи-
        каций на другие файлы.
                          
        Точную последовательность действий, необходимых для по-
        рождения новой версии программы.
Файл описаний позволяет make'у  отслеживать  зависимости  между
файлами,  составляющими программную систему. Если изменен любой
из них, утилита make порождает новую версию программы, переком-
пилировавав только те ее части, которые прямо или косвенно зат-
ронуты изменением.
                                                               
Основные операции утилиты make таковы:                         
                                                               
        Найти в файле описаний целевой файл.             
        Добиться  того, чтобы все файлы, от которых зависит це-
        левой файл, а также файлы, необходимые для его порожде
        ния, существовали и  не были устаревшими.
        Если  какой-либо из этих файлов модифицирован позже це-
        левого файла, пересоздать последний.
                                  
Файлу описаний, задающему информацию о межфайловых зависимостях
и последовательностях команд для порождения файлов, принято да
вать  имя  makefile, Makefile или s.[mM]akefile. Если следовать
этому соглашению, для достижения цели  чаще  всего  оказывается
достаточно  просто  набрать                                    
                                        
       |make
                                                               
независимо от того, сколько файлов было изменено. В большинстве
случаев файл описаний написать нетрудно, а изменяется он нечас
то. Даже если отредактирован единственный файл,  вызов  утилиты
make надежнее, чем ввод всех команд перегенерации целевого фай-
ла.
                                      
Имеется  одно  применение  утилиты  make,  с которым приходится
сталкиваться всем системным программистам -  это  перегенерация
ОС UNIX. В каталоге /usr/src/uts находится файл описаний с име-
нем Makefile, управляющий процессом перегенерации. Изучение по
добного реального примера должно способствовать лучшему понима
нию данного описания.                            
        2. ОСНОВНЫЕ ВОЗМОЖНОСТИ
                                                               
Основное действие утилиты make - обновление целевого файла  при
условии,  что все файлы, от которых зависит целевой, существуют
и не являются устаревшими. Целевой файл порождается заново, ес-
ли названные файлы модифицированы, а целевой - нет. Утилита ma
ke исследует граф зависимостей. Функционирование make'а основы-
вается на анализе времени последней модификации файлов.        
                           
Утилита make действует, опираясь на три источника информации:
            
        Заданный пользователем файл описаний.
                                                               
        Имена файлов и времена последней модификации,  получае
        мые от файловой системы.                               
                                                               
        Встроенные правила, позволяющие разрешить некоторые не-
        домолвки в файле описаний.
                                                               
В  качестве  иллюстрации  рассмотрим  следующий простой пример.
Программа prog получается из трех исходных файлов  x.c,  y.c  и
z.c  путем  их  компиляции и редактированием связей совместно с
библиотекой math. В соответствии с принятыми  соглашениями  ре
зультат  работы  C-компилятора  будет помещен в файлы с именами
x.o, y.o и z.o. Предположим также, что файлы x.c и y.c  исполь-
зуют общие описания из включаемого файла defs.h, а z.c - не ис-
пользует. Пусть x.c и y.c содержат строку                      
                                                               
       |#include "defs.h"                                      
                                                               
Следующая спецификация описывает взаимосвязи и операции:       
                                                       
       |prog :  x.o  y.o  z.o
       |        cc  x.o  y.o  z.o  -lm  -o  prog             
       |x.o  y.o :  defs.h
                                             
Если эту информацию поместить в файл с именем makefile,  команда
                                                               
       |make                    
будет  выполнять  операции,  необходимые для перегенерации prog
после любых изменений, сделанных в каком-либо из четырех исход-
ных файлов x.c, y.c, z.c или defs.h. В приведенном выше примере
в первой строке утверждается, что prog зависит от трех  .o-фай-
лов.  Если  эти файлы имеются в наличии, рассматривается вторая
строка, которая описывает, как отредактировать связи между  ни-
ми, чтобы создать prog. Третья строка гласит, что x.o и y.o за
висят от defs.h. Обратившись к файловой системе, make обнаружи-
вает,  что имеются  три .c-файла, соответствующие требуемым .o
файлам, и применяет встроенные  правила  порождения  объектного
файла из исходного C-файла (то есть выполняет команду cc -c).
Если  make  не может автоматически определить действия, которые
требуется выполнить, необходим следующий,  более  длинный  файл
описаний:                                               
       |x.o :  x.c
       |        cc  -c  x.c
       |y.o :  y.c  defs.h                                      
       |        cc  -c  y.c
       |z.o :  z.c
       |        cc  -c  z.c
                                                               
Если  ни один из исходных или объектных файлов не был изменен с
момента последнего порождения prog и все файлы в наличии,  ути-
лита  make  известит  об этом и прекратит работу. Если, однако,
файл defs.h отредактировать, x.c и y.c (но не z.c) будут  пере-
компилированы; затем из новых файлов x.o и y.o и уже существую
щего  файла z.o будет заново собрана программа prog. Если изме
нен лишь файл y.c, только он и  перекомпилируется,  после  чего
последует  пересборка prog. Если в командной строке make не за
дано имя цели, создается первый упомянутый в  описании  целевой
файл;  в  противном  случае создаются специфицированные целевые
файлы. Команда
                                                               
       |make x.o                                               
         
будет перегенерировать x.o, если изменен x.c или defs.h.
                             
Часто в файл описаний включают правила с мнемоническими именами
и  командами,  которые в действительности не порождают файлов с
соответствующими именами. Смысл в  том,  чтобы  воспользоваться
средствами  make'а  по  генерации файлов и подстановке макросов
(информацию о макросах см. в разделе ФАЙЛЫ ОПИСАНИЙ  И  ПОДСТА-
НОВКИ).  Мнемонические имена играют роль точек входа, при обра-
щении к которым выполняются определенные действия.  Так,  точка
входа  save может служить для копирования определенной совокуп-
ности файлов, а точка входа clean - для удаления ненужных  про-
межуточных файлов.                                             
                                                               
Если после выполнения таких команд файл существует, то для  то
го, чтобы принимать последующие решения, используется время его
последней  модификации;  если же он не существует, используется
текущее время.                                                 
                                                               
Еще один полезный прием состоит в том,  что  при  необходимости
отслеживать только время выполнения определенных действий целе-
сообразно  завести  пустой  файл,  который будет использоваться
только как носитель времени последней модификации.
                
Утилита  make использует простой механизм макросов для выполне-
ния подстановок в строках зависимостей и цепочках команд.  Мак-
рос  можно либо задать аргументами командной строки, либо вклю-
чить в файл описаний. В обоих случаях макроопределение  состоит
из  имени,  за  которым следует знак равенства (=), а затем то,
что макрос обозначает. При обращении к макросу перед его именем
указывается знак $. Имена макросов, состоящие более чем из  од-
ного символа, должны заключаться в скобки. Ниже приводятся при
меры корректных обращений к макросам:                          
                                                               
       |$(CFLAGS)                                              
       |$2                                                     
       |$(xy)     
       |$Z
       |$(Z)                                                   
                                                               
Две последние строки эквивалентны.                             
              
$*, $@, $?, $< - это четыре специальных макроса, значения кото-
рых изменяются во время выполнения команды. Они  описываются  в
разделе ФАЙЛЫ ОПИСАНИЙ И ПОДСТАНОВКИ. В следующем фрагменте по
казаны определения и использования некоторых макросов:         
                                                  
       |OBJECTS = x.o y.o z.o
       |LIBES = -lm                                            
       |prog: $(OBJECTS)                                       
       |        cc  $(OBJECTS) $(LIBES)  -o prog               
       |       . . .                                           
                                                               
Команда                                                        
                                                               
       |make LIBES="-ll -lm"                                   
                                     
загружает  три объектных файла вместе с библиотекой lex'а (-ll)
и математической библиотекой (-lm), потому что в первую очередь
используются макроопределения из командной строки, а не  однои-
менные  определения в файле описаний. (В командах ОС UNIX аргу-
менты, содержащие пробелы, должны заключаться в кавычки).
            
В качестве примера использования make'а приведем файл описаний,
который может применяться при сопровождении самой утилиты make.
Исходный текст утилиты содержится в нескольких C-файлах, а так-
же включает yacc-спецификацию грамматики.                      
                                                               
       |# Файл описаний для утилиты make                       
       |                                              
       |FILES = Makefile defs.h main.h doname.c misc.c
       |        files.c dosys.c gram.y
       |OBJECTS = main.o doname.o misc.o files.o
       |          dosys.o gram.o
       |LIBES = -lld                            
       |LINTS = lint -p
       |CFLAGS = -O
       |LP = /usr/bin/lp
       |
make: $(OBJECTS)    
       |       $(CC)  $(CFLAGS)  $(OBJECTS)  $(LIBES) -o make
       |                                                       
       |$(OBJECTS): defs.h                                     
       |                                                       
       |cleanup:                                               
       |        -rm *.o gram.c                           
       |        -du
       |install:                                               
       |        @size make /bin/make                           
       |        mv make /bin                                   
       |                                 
       |lint :  dosys.c doname.c files.c main.c misc.c gram.c
       |        $(LINT) dosys.c doname.c files.c main.c misc.c \
       |        gram.c
       |                                              
       |           # Распечатать файлы, состояние которых не
       |           # согласуется с "целевым файлом" print
       |                        
       |print:  $(FILES)
       |        pr $? | $(LP)
       |        touch print
                        
Перед выполнением всякой команды утилита make распечатывает  ее.
                        
Вызов утилиты make в каталоге, содержащем только указанные  ис-
ходные файлы и файл описаний, будет иметь следующий результат:
                          
       |cc -o -c main.c
       |cc -o -c doname.c
       |cc -o -c misc.c       
       |cc -o -c flies.c
       |cc -o -c dosys.c
       |yacc gram.y                 
       |mv y.tab.c gram.c   
       |cc -o -c gram.c
       |cc main.o doname.o misc.o files.o dosys.o gram.o -lld \
       |   -o make                                              
       |make: 24700 + 7100 + 18344 = 50144
       |/bin/make: 25200 + 6900 + 18108 = 50208
                                                            
Две последние строки являются результатом выполнения команды
        
size make /bin/make
                             
Печать самой командной строки подавляется знаком @ в файле опи-
саний.
        3. ФАЙЛЫ ОПИСАНИЙ И ПОДСТАНОВКИ                         
В данном разделе описываются основные компоненты  файла  описа
ний.                                                          
        3.1. Комментарии
                         
Признаком  комментария,  по  соглашению, является символ #; все
символы за ним до конца строки игнорируются.  Пустые  строки  и
строки, начинающиеся с #, игнорируются полностью.
                   
        3.2. Строки продолжения
                       
Слишком  длинную строку, не являющуюся комментарием, можно про-
должить, используя знак \. Если последним символом строки явля-
ется символ \, то он, а также перевод строки и все следующие за
ним пробелы и табуляции заменяются на одиночный пробел.
        3.3. Макроопределения                               
Макроопределение - это идентификатор, за которым  следует  знак
равенства. Перед идентификатором не должно стоять двоеточия или
табуляции.  Имя  (цепочка  букв  и/или цифр) слева от знака ра
венства (завершающие пробелы и табуляции отбрасываются)  сопос-
тавляется  цепочке символов, следующей за знаком равенства (на-
чальные пробелы и табуляции отбрасываются). Ниже приведены кор-
ректные макроопределения:                                      
    
   |2 = xyz
       |abc = -ll -ly -lm
       |LIBES =
                                                               
Последнее определение сопоставляет  LIBES  с  пустой  цепочкой.
Макрос,  нигде  не определенный явным образом, имеет в качестве
значения пустую цепочку. Напомним, однако, что некоторые макро-
сы явно определяются во встроенных правилах утилиты make.  (См.
раздел ВСТРОЕННЫЕ ПРАВИЛА.)
                                                               
        3.4. Общий вид файла описаний                          
                                                               
Общий вид точки входа в файле описаний таков:          
       |цель1  [цель2 ...]  :[:]  [зависимость1 ...]
       |[; команды]  [# ...]    [\t команды ]  [# ...]
                                                               
Указанные в скобках компоненты могут быть опущены, цели и зави-
симости являются цепочками из букв, цифр, символов . и  /.  При
обработке  строки  интерпретируются  метасимволы shell'а, такие
как * и ?. Команды могут быть указаны после точки с  запятой  в
строке  зависимостей,  или в строках, начинающихся с табуляции,
которые следуют сразу за строкой зависимостей.  Команда  -  это
произвольная  цепочка символов, не содержащая знак #, за исклю-
чением тех случаев, когда # заключен в кавычки.
                         
        3.5. Информация о зависимостях
В строке зависимостей может быть указан одинарный либо  сдвоен-
ный  знак  двоеточия. Целевое имя может встречаться более чем в
одной  строке  зависимостей,  однако все эти строки должны быть
одного (либо с одинарным, либо со сдвоенным двоеточием) типа. В
более распространенном случае (одинарное двоеточие)  последова-
тельность  команд  может  быть  сопоставлена не более чем одной
строке зависимостей. Если целевой файл устарел по  сравнению  с
какой-либо зависимостью в любой из этих строк и специфицирована
последовательность  команд (даже если после точки с запятой или
табуляции идет пустая цепочка), данная  последовательность  ко-
манд выполняется; иначе может быть вызвано встроенное  правило.
В  случае со сдвоенным двоеточием последовательность команд мо-
жет быть сопоставлена более чем одной строке зависимостей. Если
целевой  файл устарел по сравнению с какой-либо зависимостью из
одной из этих строк, выполняются соответствующие команды. Также
может быть выполнено встроенное  правило.  Форма  со  сдвоенным
двоеточием особенно полезна для обновления архивных файлов, где
целевой  файл  - это сама архивная библиотека. (Соответствующий
пример содержится в пункте Архивные библиотеки.)               
                                                               
        3.6. Исполняемые команды               
Если  целевой  файл  должен быть создан, выполняется последова-
тельность команд. Обычно каждая командная строка распечатывает-
ся и затем, после подстановки макросов, для ее  выполнения  за
пускается очередной экземпляр shell'а. Печать может быть подав-
лена в режиме "молчания" (опция -s утилиты make) или в том слу-
чае, если командная строка в файле описаний начинается со знака
@.  make обычно прекращает работу, если какая-либо команда сиг
нализирует об ошибке, возвращая ненулевой код завершения. Ошиб-
ки  игнорируются,  если в командной строке make'а указана опция
-i, или если в файле описаний  указано  фиктивное  целевое  имя
.IGNORE,  или если командная строка в файле описаний начинается
со знака минус. Если известно, что программа возвращает  бесс
держательное  значение,  полезно указывать минус перед строкой,
ее запускающей. Поскольку каждая  командная  строка  передается
отдельному  экземпляру  shell'а,  при использовании собственных
команд shell'а [например, cd(1)] надо  проявлять  осторожность,
потому  что они имеют смысл только в пределах одного shell-про-
цесса. Перед выполнением следующей строки результаты выполнения
этих команд утрачиваются.                                      
                                                               
Перед вызовом любой команды устанавливаются некоторые  встроен-
ные макросы. Макрос $@ устанавливается равным полному имени те-
кущего целевого файла. Он вычисляется только для явно указанных
зависимостей.  Макрос  $?  устанавливается  равным цепочке имен
файлов, которые оказались более свежими, чем целевой; он  также
вычисляется  только при обработке явных правил make-файла. Если
команда порождена неявным правилом, макрос $< равен имени  фай
ла,  вызвавшего  действие; макрос $* - префикс имени, общий для
текущего файла и файла из строки зависимостей. Если файл должен
быть получен, но нет явных команд или  встроенных  правил,  ис-
пользуются  команды,  сопоставленные  фиктивному целевому имени
.DEFAULT. Если такого имени нет, make выдает сообщение и  прек
ращает работу.                                                 
                                                               
Кроме того, в файле описаний можно использовать следующие  свя-
занные с упомянутыми выше макросы: $(@D), $(@F), $(*D),  $(*F),
$(<D) и $(<F) (см. ниже).                                      
                                                               
        3.7. Усовершенствования $*, $@, $<                     
                                                               
Внутренние макросы $*, $@ и $< - полезные обозначения для теку
щих целевых файлов и устаревших файлов, связанных с целевыми. К
этому списку следует дабавить следующие макросы: $(@D),  $(@F),
$(*D),  $(*F), $(<D) и $(<F). Модификатор D обозначает маршрут-
ную часть полного имени файла, соответствующего односимвольному
макросу, а модификатор F - простое имя. Эти дополнительные мак
росы бывают полезны при построении  иерархических  make-файлов.
Они  позволяют получить доступ к имени каталога, чтобы восполь-
зоваться командой cd(1). Например, можно написать              
                                                               
       |cd $(<D); $(MAKE) $(<F)                                
                                                               
        3.8. Выходные преобразования макросов                  
                                                               
Вхождения макросов в команды shell'а раскрываются в момент  вы-
полнения. В общем случае обращение к макросу выглядит так:     
              
       |$(макро:цепочка1=цепочка2)
                                                               
Подобная  конструкция  преобразуется следующим образом. Сначала
определяется значение $(макро). Затем каждое вхождение цепочки1
в данное значение заменяется на цепочку2;  при  этом  вхождение
цепочки1  в  $(макро) понимается как сопоставление с регулярным
выражением вида
                                                               
       |.*цепочка1[табуляция|пробел]                           
                                                               
то есть значение $(макро) рассматривается как набор разделенных
пробелами или табуляциями цепочек символов и в конце этих цепо-
чек цепочка1 заменяется на цепочку2.                           
                                                               
Описанная форма выходных преобразований макросов  была  выбрана
потому,  что  make обычно имеет дело с окончаниями имен файлов.
Польза выходных преобразований становится очевидной при поддер-
жании архивных библиотек. В следующем примере модификация  биб-
лиотеки выполняется за один просмотр:
                                             
       |$(LIB) : $(LIB)(a.o) $(LIB)(b.o) $(LIB)(c.o)
       |         $(CC) -c $(CFLAGS) $(?:.o=.c)                 
       |         $(AR) $(ARFLAGS) $(LIB) $?               
       |         rm $?
                                  
Зависимость указанного вида необходима для каждого из типов ис-
ходных файлов (суффиксов), результаты трансляции которых  обра-
зуют  архивную  библиотеку.  Выходные  преобразования позволяют
воспользоваться той богатой информацией, которую  предоставляет
make.                                                          
        4. РЕКУРСИВНЫЕ MAKE-ФАЙЛЫ
Еще  одна  особенность  утилиты make касается учета окружения и
возможности  рекурсивных  запусков.  Если  в  командной  строке
shell'а  где-либо  указана  последовательность  $(MAKE), данная
строка выполняется, даже если установлен флаг -n. Так как  флаг
-n распространяется по цепочке вызовов make'а (через переменную
MAKEFLAGS), единственное выполняемое действие - это сама коман-
да make. Данная особенность полезна в тех случаях, когда иерар-
хия  make-файлов описывает совокупность компонентов программных
систем. Обращение make -n ... можно использовать для целей  от
ладки;  при этом распечатываются все те команды, которые должны
быть выполнены, а также вывод вложенных вызовов утилиты make.
        4.1. Суффиксы и правила трансформации       
                                              
Утилита make использует таблицу встроенных  правил,  определяю-
щих,  как  преобразовать файл с одним суффиксом в файл с другим
суффиксом. Если в  командной  строке  make'а  указан  флаг  -r,
встроенная таблица не используется.                            
                                                               
В  действительности список суффиксов совпадает со списком зави-
симостей для имени .SUFFIXES. make пытается найти файл с  одним
из  суффиксов из списка. Если такой файл найден, make трансфор-
мирует его в файл с другим суффиксом. Имена правил  трансформа-
ции  -  это  просто  конкатенации  суффиксов  файлов до и после
трансформации. Так, правило трансформации .c-файла в в  .o-файл
называется  .c.o. Если данное правило существует, а в пользова-
тельских файлах описаний не задано явной последовательности ко-
манд, используется последовательность  команд,  соответствующая
правилу .c.o. Если команда порождается при помощи одного из та-
ких  правил, посредством макроса $* можно получить основу (все,
кроме суффикса) имени файла; макрос $<  обозначает  полное  имя
файла из строки зависимостей, вызвавшего выполнение действия.  
                                                               
Порядок  суффиксов в списке существенен, поскольку список прос-
матривается слева направо. Используется  первое  сформированное
имя  -  то,  для которого имеется и файл, и соответствующее ему
правило. Если надо добавить новые имена, пользователь может до-
бавить запись в правило .SUFFIXES в файле описаний. Зависимости
добавляются к стандартному списку. Строка .SUFFIXES, не  содер
жащая  зависимостей, делает текущий список пустым. Если порядок
имен надо изменить, текущий список должен быть очищен.         
                                   
        4.2. Подразумеваемые правила
                                                               
Для того, чтобы задать информацию о подразумеваемых  зависимос-
тях и соответствующих им командах, утилита make использует таб
лицу  суффиксов и набор правил трансформации. По умолчанию спи
сок суффиксов выглядит так:                                    
                                                               
        .o   объектный файл                                    
                                                               
        .c   исходный C-файл                                   
                                                               
        .c~  исходный SCCS C-файл                              
                                                               
        .f   исходный f77-файл                               
        .f~  исходный SCCS f77-файл                            
                                                               
        .s   исходный файл на языке ассемблера                 
                                                               
        .s~  исходный SCCS-файл на языке ассемблера            
                                                               
        .y   исходная yacc-грамматика                          
                                                      
        .y~  исходная SCCS yacc-грамматика
                                    
        .l   исходная lex-спецификация
                                                               
        .l~  исходный SCCS lex-спецификация                    
                                                               
        .h   включаемый файл
        .h~  включаемый SCCS-файл
        .sh  командный файл 
        .sh~ командный SCCS-файл 
Следующий рисунок содержит сводку подразумеваемых путей  транс-
формации.  Если имеется два пути, соединяющих определенную пару
суффиксов, более длинный путь используется только в тех  случа-
ях, когда промежуточный файл существует либо упоминается в опи-
сании.                                        
          |                       .o               
          |                       |
          |       +-------+-------+-------+-------+
          |       |       |       |       |       |
          |                               
          |       .c      .f      .s      .y      .l
          |                           
          |   +---+---+
          |   |       |                    
          |
          |   .y      .l    
Если  требуется файл x.o, а в описании или каталоге найден файл
x.c, x.c будет откомпилирован. Если, кроме того,  имеется  файл
x.l, он будет обработан lex'ом, после чего будет откомпилирован
результат обработки. Однако, если файл x.c отсутствует, но есть
x.l,  make воспользуется правилом прямой трансформации и отбро-
сит промежуточный C-файл.
                                                               
Можно изменить имена некоторых используемых по умолчанию компи-
ляторов, а также опции, с которыми компиляторы вызываются.  Для
этого  предусмотрены  макросы  с  определенными именами. Именам
компиляторов соответствуют макросы AS, CC, F77, YACC, LEX.  Ко-
манда
                               
       |make CC=newcc              
                                                   
будет  приводить к использованию вместо стандартного C-компиля-
тора команды newcc. Чтобы компиляторы  запускались  с  дополни-
тельными  опциями, можно устанавливать макросы ASFLAGS, CFLAGS,
F77FLAGS, YFLAGS и LFLAGS. Так, вызов
                       
       |make "CFLAGS=-g"
           
заставляет команду cc(1) включать в файл отладочную  информацию.
        4.3. Архивные библиотеки                               
                                                               
Утилита make предоставляет интерфейс  для  работы  с  архивными
библиотеками.  В файле описаний пользователь может обратиться к
элементу библиотеки следующим образом:                         
                         
       |библиотека(файл.o)
                                                               
или                                                            
                                                               
       |библиотека(точка_входа)                                
     
Второй метод является в действительности ссылкой на точку входа
в объектном файле, содержащемся в библиотеке. make просматрива-
ет библиотеку, обнаруживает точку входа и преобразует ее в кор-
ректное имя объектного файла.                                  
                                                               
Чтобы воспользоваться данной процедурой для поддержания  архив-
ной библиотеки, необходим make-файл следующего вида:
       |projlib::   projlib(pfile1.o)
       |        $(CC) -c -O pfile1.c
       |        $(AR) $(ARFLAGS) projlib pfile1.o               
       |        rm pfile1.o
       |projlib::   projlib(pfile2.o)
       |        $(CC) -c -O pfile2.c
       |        $(AR) $(ARFLAGS) projlib pfile2.o              
       |        rm pfile2.o                                    
       | . . . и так далее для каждого элемента библиотеки
Это утомительно и чревато  ошибками.  Очевидно,  последователь-
ность команд для включения C-файла в библиотеку повторяется для
каждого  запуска; единственное отличие заключается в имени фай-
ла. (Данное утверждение истинно в большинстве случаев.)
                               
Утилита make предоставляет пользователю правила для  построения
библиотек. Этим правилам соответствует суффикс .a. Так, правило
.c.a  - это правило компиляции исходного C-файла, включения его
в библиотеку и удаления  промежуточного  .o-файла.  Аналогично,
правила  .y.a, .s.a и .l.a заново обрабатывают, соответственно,
файлы yacc'а, ассемблера и lex'а. Встроенными являются следущие
правила для работы с  архивами:  .c.a,  .c~.a,  .f.a,  .f~.a  и
.s~.a.  (Назначение  тильды,  ~, будет ниже коротко описано.) В
файле описаний пользователь может определить другие необходимые
ему правила.                         
                                    
Поскольку встроенные правила для поддержания библиотеки уже оп-
ределены, упомянутую выше библиотеку, состоящую из двух элемен-
тов,  можно  поддерживать при помощи следующего более короткого
make-файла:                         
                                                 
       |projlib:        projlib(pfile1.o) projlib(pfile2.o)
       |           @echo projlib up-to-date               
На самом деле правило .c.a выглядит так:                       
                                                               
       |.c.a:                                                  
       |        $(CC) -c $(CFLAGS) $<                  
       |        $(AR) $(ARFLAGS) $@ $*.o
       |        rm -f $*.o                                     
                                                               
Здесь макрос $@ обозначает целевой файл  (библиотеку  projlib);
макросы  $< и $* устанавливаются равными, соответственно, имени
изменившегося C-файла и имени файла без  суффикса  (pfile1.c  и
pfile1).  Макрос $< (в приведенном выше правиле) можно заменить
на $*.c.                                                       
                                                               
Полезно в деталях рассмотреть, как make обрабатывает  следующую
конструкцию:
       |projlib:        projlib(pfile1.o)                      
       |           @echo projlib up-to-date                    
                                                               
Предположим, что объектный файл, содержащийся в библиотеке,  по
сравнению  с  pfile1.c  устарел.  Кроме того, файл pfile1.o от-
сутствует.                                                 
                                           
Выполняются следующие действия:
                                        
        make projlib.
             
        При  выполнении make projlib сначала проверить все фай-
        лы, от которых зависит projlib. 
                          
        Архив  projlib  зависит  от элемента projlib(pfile1.o),
        который необходимо сгенерировать.                      
                                                               
        Перед  тем  как генерировать элемент projlib(pfile1.o),
        проверить все файлы, от которых он зависит. (Таких фай-
        лов нет.)
        Использовать встроенные правила для того,  чтобы  попы-
        таться  создать projlib(pfile1.o). (Встроенного правила
        нет.) Отметим, что цепочка  projlib(pfile1.o)  содержит
        скобки для того, чтобы указать на суффикс целевого фай-
        ла  .a.  В  конце имени архива projlib суффикс .a явным
        образом не написан, но скобки его подразумевают. В этом
        смысле суффикс .a жестко запаян в make.                
                                                               
        Разбить  имя  projlib(pfile1.o)  на projlib и pfile1.o.
        Определить два макроса: $@(=projlib) и $*(=pfile1).
                               
        Попытаться найти правило .X.a и файл $*.X. Первый .X (в
        списке .SUFFIXES), который удовлетворяет этим условиям,
        это .c; поэтому выбирается правило .c.a и файл  -  pfi-
        le1.c. Установить $< равным pfile1.c и выполнить данное
        правило. В действительности make должен откомпилировать
        pfile1.c.
                                                               
        Обновить библиотеку. Выполнить команду, соответствующую
        projlib: зависимости, то есть
                                                               
            |@echo projlib up-to-date                          
                 
Следует напомнить, что для того, чтобы pfile1.o зависел от  ка-
ких-либо  файлов,  требуется  поместить в файл описаний запись,
подобную                                                       
                                                               
       |projlib(pfile1.o):      $(INCDIR)/stdio.h pfile1.c     
                                                               
На  случай использования подобной конструкции предусмотрен мак-
рос для ссылки на имя элемента архива. Всякий раз, когда вычис-
ляется макрос $@, вычисляется и $%. Если текущего элемента  ар-
хива нет, $% полагается равным пустой цепочке. Если элемент ар-
хива существует, то $% равно выражению в скобках.          
        5. ИМЕНА SCCS-ФАЙЛОВ (ТИЛЬДА)
                                                               
Синтаксис make'а не позволяет непосредственно ссылаться на пре-
фиксы имен файлов. Для большинства типов файлов в  операционной
системе UNIX это приемлемо, поскольку почти повсеместно для оп-
ределения  типа файлов используется суффикс. Исключение состав-
ляют SCCS-файлы. В этом случае s. является префиксом компонента
имени файла в полном маршрутном имени.
                                                               
Чтобы облегчить утилите make обращение с префиксом  .s,  в  ка-
честве  признака  SCCS-файлов  используется  символ ~ (тильда).
Так, .c~.o обозначает правило, преобразующее исходный SCCS-файл
на языке C в объектный файл. Именно, встроенное правило  выгля-
дит так:                                                       
                                                               
       |.c~.o:
       |        $(GET) $(GFLAGS) $<
       |        $(CC) -c $(CFLAGS) $*.c                   
       |        -rm -f $*.c
                                                               
Таким образом, тильда, добавленная к любому суффиксу, трансфор
мирует поиск обычного файла в  поиск  SCCS-файла  с  суффиксом,
состоящим  из  точки  и  всех символов первоначального суффикса
вплоть до (но не включая) тильды.                
                                     
Встроенными являются следующие суффиксы SCCS:
                                                               
       |.c~                                                    
       |.f~                                                    
       |.y~                                                    
       |.l~                                                    
       |.s~                           
       |.sh~
       |.h~                                                    
                                                               
Встроены также следующие правила трансформации SCCS-файлов:    
                                                               
       |.c~:
       |.f~:
       |.sh~: 
       |.c~.a:                     
       |.c~.c:                         
       |.c~.o:             
       |.f~.a:
       |.f~.f:                                                 
       |.f~.o:                                                 
       |.s~.a:                                                 
       |.s~.s:                   
       |.s~.o:
       |.y~.c:                               
       |.y~.o:
       |.l~.l:
       |.l~.o:
       |.h~.h:
           
Естественно,  пользователь  имеет возможность определить другие
правила и суффиксы, которые кажутся ему полезными. Тильда обес-
печивает необходимые средства для работы с именами  SCCS-файлов.
        5.1. Пустой суффикс                                
Многие программы состоят из единственного исходного файла.  Для
обработки  этих  случаев  утилита  make предоставляет правило с
пустым суффиксом. Так, чтобы поддерживать  системную  программу
cat(1),  требуется make-файл, содержащий правило следующего ви-
да:           
              
       |.c:   
       |        $(CC) $(CFLAGS) $< -o $@
              
На  самом  деле,  поскольку  правило .c является встроенным, не
нужно вообще никакого make-файла. Пользователю надо только наб-
рать          
              
       |make cat dd echo date
              
(указанные программы состоят из одного файла), и все четыре ис-
ходных  C-файла передаются из командной строки shell'а на обра-
ботку при помощи .c-правила. Встроены следующие правила с одним
суффиксом:                                                     
                                                               
       |.c:                                                     
       |.c~:
       |.f:                
       |.f~:
       |.sh:                                                   
       |.sh~:                                                  
                                                               
Пользователь может включить в make-файл дополнительные  правила.
   
     5.2. Включаемые файлы
           
Утилита make предоставляет возможность,  аналогичную  директиве
#include препроцессора языка C. Если первые семь символов в ка-
кой-либо строке make-файла составляют цепочку include, а за ни-
ми следует пробел либо табуляция, остаток строки считается име
нем  файла, который будет прочитан текущим запуском утилиты ma-
ke. В именах включаемых файлов могут быть использованы макросы.
Описатели читаемых  включаемых  файлов  накапливаются,  поэтому
число  вложенных  включаемых  файлов  ограничено (не может быть
больше 16).                                                    
                                                               
        5.3. make-файлы в рамках SCCS                          
          
Make-файлы могут управляться системой SCCS. Так,  если  набрана
команда    
            
       |make
            
и имеются только файлы s.makefile или s.Makefile, make  сначала
выполнит команду get(1), а затем обработает и удалит файл.
        5.4. Динамические параметры зависимостей                
Параметр имеет смысл только в  строке зависимостей  make-файла.
$$@  обозначает  часть  текущей строки слева от двоеточия ($@).
Кроме того, имеется параметр $$(@F), позволяющий получить  дос-
туп  к обозначающему файл компоненту $@. Так, в следующей запи
си:                                                            
                                                               
       |cat:    $$@.c                                          
                                                               
строка зависимостей в момент выполнения преобразуется в цепочк
cat.c.  Это  полезно  для построения большого числа выполняемых
файлов, у каждого из которых только один исходный файл.  Напри-
мер,  в  каталоге,  содержащем утилиты системы UNIX, может быть
make-файл вида:                      
       |CMDS = cat dd echo date cmp comm chown                 
       |
       |$(CMDS):        $$@.c
       |        $(CC) -O $? -o $@
Конечно, это только подмножество  всех  однофайловых  программ.
Для программ, состоящих из многих файлов, обычно заводится спе-
циальный каталог и формируется отдельный make-файл. Для каждого
конкретного файла, требующего специфической процедуры  компиля-
ции, в make-файле должна быть предусмотрена особая запись.
                                                               
Еще одна полезная форма параметра зависимостей -  $$(@F).  Этот
параметр представляет обозначающую файл часть $$@. Он также вы
числяется во время выполнения. Его польза становится очевидной,
если  попытаться  поддерживать  каталог /usr/include при помощи
make-файла, который находится в  каталоге  /usr/src/head.  Файл
описаний /usr/src/head/makefile должен выглядеть так:
       |INCDIR = /usr/include                                  
       |                                                       
       |INCLUDES = \                                           
       |        $(INCDIR)/stdio.h                              
       |        $(INCDIR)/pwd.h
       |        $(INCDIR)/dir.h
       |        $(INCDIR)/a.out.h             
       |$(INCLUDES): $$(@F)  
       |        cp $? $@         
       |        chmod 0444 $@
                                                               
Использование  этого make-файла должно приводить в полное соот
ветствие содержимое каталога /usr/include при обновлении люб
из упомянутых файлов, расположенных в каталоге /usr/src/head.  
        6. ЗАПУСК УТИЛИТЫ MAKE                            
Описание  утилиты  make содержится в статье make(1) Справочника
пользователя.                                                  
                                                               
        6.1. Командная строка                                  
                                                               
Макроопределения, опции, имена файлов описаний и целевых файлов
могут  быть переданы утилите make как аргументы командной стро-
ки, имеющей следующий вид:   
        
make  [опции] [макроопределения] [целевые_файлы]
                                 
Аргументы  командной строки интерпретируются следующим образом.
Прежде всего анализируются аргументы, являющиеся макроопределе-
ниями (то есть аргументы, содержащие внутри себя знаки равенст-
ва), и выполняются необходимые присваивания. Макросы,  заданные
в  командной строке, имеют приоритет над макросами, заданными в
файле описаний. Затем рассматриваются аргументы-опции. Допуска-
ются следующие опции:        
        -i   Игнорировать коды ошибок, возвращаемых запускаемы
             ми программами.  Данный  режим  устанавливается  и
             тогда,  когда  в  файле описаний указано фиктивное
             целевое имя .IGNORE.
        -s   Молчи, скрывайся и таи...  Не  выводить  командные
             строки перед их выполнением. Данный режим устанав-
             ливается  и  тогда, когда в файле описаний указано
             фиктивное целевое имя .SILENT.
        -r   Не использовать встроенные правила.               
                                                               
        -n   Пробный режим. Распечатывать команды, но не выпол-
             нять их. Выводятся даже команды,  начинающиеся  со
             знака @.                                   
        -t   "Массаж" целевых_файлов: время их  создания  уста-
             навливается  равным  текущему  времени;   команды,
             предназначенные для получения  целевых_файлов,  не
             выполняются.                                      
                                                               
        -q   Запрос.  Утилита make возвращает нулевой или нену
             левой код завершения в зависимости от того,  нужно
             ли обновлять целевые_файлы (0, если не нужно).
                                                               
        -p   Вывести все макроопределения, а также все описания
             целевых_файлов.                                   
                                 
        -k   При ошибке прекращать выполнение команд, связанных
             с текущей зависимостью,  но  продолжать  обработку
             других зависимостей, не связанных с текущей.      
                                                               
        -e   Использовать в первую очередь  переменные  окруже-
             ния, а не одноименные макросы make-файлов.
                                                
        -f   Следующий аргумент считается именем  файла  описа-
             ний. Имя файла - обозначает стандартный ввод. Если
             опция  -f не указана, читается файл с именем make-
             file, Makefile или s.[mM]akefile из текущего ката-
             лога. В  первую  очередь  используется  содержимое
             файлов описаний, а не встроенные правила.         
                                                               
Следующие  два  аргумента обрабатываются в точности так же, как
опции:                   
        .DEFAULT                                               
             Если некоторый файл должен быть получен, но нет ни
             явных команд, ни соответствующих  встроенных  пра-
             вил,  то  используются команды, ассоциированные со
             специальным целевым именем .DEFAULT, если оно ука-
             зано.          
        .PRECIOUS                                              
             Файлы, которые зависят от этого специального  име-
             ни,  не  удаляются,  если работа утилиты make была
             прервана или прекращена.
                                                               
После этого все оставшиеся аргументы считаются именами  целевых
файлов, которые должны быть сформированы; аргументы обрабатыва-
ются  слева  направо.  Если  таких аргументов нет, используется
первое имя в файле описаний, не начинающееся с точки.          
                                                               
        6.2. Переменные окружения                              
                                                               
Всякий раз, когда выполняется утилита make, читаются и добавля-
ются к макроопределениям переменные  окружения.  Чтобы  пользо-
ваться  этим  механизмом должным образом, важнее всего рассмот-
реть приоритетность  различных  определений.  Ниже  описывается
взаимодействие  make'а  с окружением. Утилита make поддерживает
макрос MAKEFLAGS. Данный макрос определяется как цепочка,  сос-
тоящая из всех входных аргументов-флагов (без знаков -). Макрос
экспортируется  и  тем самым становится доступным вложенным з
пускам make'а. Флаги командной строки и присваивания,  содержа-
щиеся  в  make-файле,  обновляют значение MAKEFLAGS. Чтобы опи
сать, как окружение взаимодействует с утилитой make, необходимо
рассмотреть макрос MAKEFLAGS.
                 
Выполняясь, make формирует макроопределения в следующем  поряд
ке:                                                            
                                     
        Читает переменную окружения  MAKEFLAGS.  Если  она  от-
        сутствует либо пуста, внутренняя переменная утилиты ma-
        ke  MAKEFLAGS  устанавливается равной пустой цепочке. В
        противном случае каждая буква в значении переменной ок-
        ружения MAKEFLAGS считается входным аргументом-флагом и
        соответствующим  образом  обрабатывается.   (Исключение
        составляют опции -f, -p и -r.)
        Читает встроенный список макроопределений.             
                                                               
        Читает  окружение.  Переменные окружения трактуются как
        макроопределения и  помечаются  как  экспортируемые  (в
        смысле shell'а).                                       
                                                               
        Читает  make-файл (файлы). В первую очередь учитываются
        присваивания, указанные в make-файлах, а не  в  окруже
        нии.  Такой порядок выбран для того, чтобы при чтении и
        обработке make-файла результат был предсказуем.  Данное
        соглашение выполняется, если только не используется оп-
        ция  -e, задающая приоритет окружения. Если имеется яв-
        ное присваивание переменной MAKEFLAGS, оно также учиты-
        вается в первую очередь. Эта возможность бывает  удобна
        при  вложенных  запусках утилиты make из текущего make-
        файла.
                                                               
Полезно привести список приоритетов присваиваний. Ниже перечис
ляются установки макропределений в порядке возрастания их стар-
шинства:                                                       
                                                               
        Внутренние макроопределения.                           
                                      
        Окружение.
                                                  
        Файл (файлы) с описаниями.
                                                               
        Командная строка.                                      
                        
Использование опции -e приводит к некоторому изменению  порядка:
                                                               
        Внутренние макроопределения.                           
                                                               
        Файл (файлы) с описаниями.                             
                                                               
        Окружение.                                             
                                                               
        Командная строка.                                      
                                                               
Описанный порядок достаточно универсален, чтобы позволить прог-
раммисту задать make-файл или набор make-файлов, параметры  ко-
торых могут определяться динамически.                          
        7. СОВЕТЫ И ПРЕДОСТЕРЕЖЕНИЯ                            
        
Чаще  всего причиной возникновения трудностей является специфи-
ческая трактовка утилитой make понятия зависимостей. Если  файл
x.c содержит строку
                  
       |#include "defs.h"
                                  
считается, что от defs.h зависит объектный файл x.o, но не  ис-
ходный  файл x.c. Если defs.h изменяется, с x.c ничего не дела-
ется, в то время как x.o должен быть создан заново.
                                                                
Чтобы  понять,  какие  действия будет делать make, очень удобно
использовать опцию -n. Обращение    
       |make -n                   
предписывает выводить команды, которые make  должен  вычислять,
не тратя на самом деле времени на их выполнение.
                         
Если  абсолютно  точно известно, что изменение в файле касается
только его внешнего представления (например, вставка  коммента
рия  во  включаемый файл), использование опции -t может сэкон
мить уйму времени. Вместо запуска большого числа ненужных пере-
компиляций make просто  обновит  времена  изменения  затронутых
файлов. Так, команда
                                                               
       |make -ts                                               
                   
приведет  в  соответствие  времена  модификации соответствующих
файлов. Очевидно, при использовании опции -t требуется осторож-
ность, поскольку данный режим обработки отменяет первоначальное
назначение утилиты make и разрушает всю информацию о более ран
них изменениях.                                                
        8. ВСТРОЕННЫЕ ПРАВИЛА                      
Ниже приводится стандартный набор встроенных правил, используе-
мых утилитой make.              
       |#      
       |#       Суффиксы, распознаваемые make
       |#                                                      
       |.SUFFIXES: .o .c .c~ .y .y~ .l .l~ .s .s~ .h .h~ \
       |           .sh .sh~ .f .f~
                                                               
       |#                                                      
       |#       Предопределенные макросы                       
       |#                                                      
       |MAKE=make                                              
       |AR=ar       
       |ARFLAGS=-rv
       |AS=as   
       |ARFLAGS=
       |CC=cc                                                  
       |CFLAGS=-O                                              
       |F77=f77                                                
       |F77FLAGS=                                              
       |GET=get
       |GFLAGS=              
       |LEX=lex
       |LFLAGS=                                                
       |LD=ld     
       |LDFLAGS=
       |YACC=yacc
       |YFLAGS=                              
         
       |#                                                 
       |#       Правила с одним суффиксом
       |#
       |.c:
       |        $(CC) $(CFLAGS) $(LDFLAGS) $< -o $@
         
       |.c~:     
       |        $(GET) $(GFLAGS) $<
       |        $(CC) $(CFLAGS) $(LDFLAGS) $*.c -o $*
       |        -rm -f $*.c
                
       |.f:  
       |        $(F77) $(F77FLAGS) $(LDFLAGS) $< -o $@
               
       |.f~:     
       |        $(GET) $(GFLAGS) $<
       |        $(F77) $(F77FLAGS) $(LDFLAGS) $< -o $*
       |        -rm -f $*.f
               
       |.sh: 
       |        cp $< $@; chmod 0777 $@
                 
       |.sh~:  
       |        $(GET) $(GFLAGS) $<
       |        cp $*.sh $*; chmod 0777 $@
       |        -rm -f $*.sh             
         
       |#  
       |#       Правила с двумя суффиксами         
       |#
c~.c .f~.f .s~.s .sh~.sh .y~.y .l~.l .h~.h:
                                                     
       |.c.a:              
       |        $(CC) -c $(CFLAGS) $<
       |        $(AR) $(ARFLAGS) $@ $*.o
       |        rm -f $*.o                            
       |.c~.a:
  $(CC) -c $(CFLAGS) $*.c               
       |        $(AR) $(ARFLAGS) $@ $*.o
       |        rm -f $*.[co]
            
       |.c.o:                          
       |        $(CC) -c $(CFLAGS) $<
             
       |.c~.o:                     
       |        $(GET) $(GFLAGS) $<       
       |        $(CC) -c $(CFLAGS) $*.c
       |        -rm -f $*.c
         
       |.f.a:                             
       |        $(F77) $(F77FLAGS) $(LDFLAGS) -c $*.f
       |        $(AR) $(ARFLAGS) $@ $*.o            
       |        -rm -f $*.o        
       |.f~.a:
  $(GET) $(GFLAGS) $<  
       |        $(F77) $(F77FLAGS) $(LDFLAGS) -c $*.f
       |        $(AR) $(ARFLAGS) $@ $*.o
       |        -rm -f $*.[fo]
              
       |.f.o:                      
       |        $(F77) $(F77FLAGS) $(LDFLAGS) -c $*.f
                                        
       |.f~.o:               
       |        $(GET) $(GFLAGS) $<
       |        $(F77) $(F77FLAGS) $(LDFLAGS) -c $*.f
       |        -rm -f $*.f          
       |.s~.a
   $(AS) $(ASFLAGS) -o $*.o $*.s
       |        $(AR) $(ARFLAGS) $@ $*.o
       |        -rm -f $*.[so]
             
       |.s.o:                                        
       |        $(AS) $(ASFLAGS) -o $@ $<
                           
       |.s~.o:
       |        $(GET) $(GFLAGS) $<
       |        $(AS) $(ASFLAGS) -o $*.o $*.s
       |        -rm -f $*.s                          
                                        
       |.l.c:                 
       |        $(LEX) $(LFLAGS) $<
       |        mv lex.yy.c $@
                                                     
       |.l~.c:
       |        $(GET) $(GFLAGS) $<
       |        $(LEX) $(LFLAGS) $*.l
       |        mv lex.yy.c $@                       
       |        rm -f $*.l 
       |.l.o: 
  $(LEX) $(L
       |        $(CC) $(CFLAGS) -c lex.yy.c  
       |        rm lex.yy.c             
       |        mv lex.yy.o $@
       |.l~.o:
  $(GET) $(GFLAGS) $<      
       |        $(LEX) $(LFLAGS) $*.l
       |        $(CC) $(CFLAGS) -c lex.yy.c
       |        rm lex.yy.c $*.l   
       |        mv lex.yy.o $*.o             
                           
       |.y.c:
       |        $(YACC) $(YFLAGS) $<
       |        mv y.tab.c $@      
                              
       |.y~.c:
       |        $(GET) $(GFLAGS) $<
       |        $(YACC) $(YFLAGS) $*.y
       |        mv y.tab.c $@        
       |        -rm -f $*.y   
                          
       |.y.o:
       |        $(YACC) $(YFLAGS) $<
       |        $(CC) $(CFLAGS) -c y.tab.c
       |        rm y.tab.c                 
       |        mv y.tab.o $@
                              
       |.y~.o:
       |        $(GET) $(GFLAGS) $<
       |        $(YACC) $(YFLAGS) $*.y
       |        $(CC) $(CFLAGS) -c y.tab.c
       |        rm -f y.tab.c $*.y         
       |        mv y.tab.o $*.o