Спец курс (Автоматизация процесса проектирования)/Лекция 6 (MAKE) - История изменений

Vidokq: /* "Перекрытие" (overriding) переменных */

2018-04-27T21:49:59Z

‎"Перекрытие" (overriding) переменных

Vidokq: /* Синтаксис вызова функций */

2018-04-27T21:49:21Z

‎Синтаксис вызова функций

Vidokq: /* Проверка опций запуска make в условных конструкциях */

2018-04-27T21:48:49Z

‎Проверка опций запуска make в условных конструкциях

Vidokq: /* Синтаксис условных конструкций */

2018-04-27T21:48:17Z

‎Синтаксис условных конструкций

Vidokq: /* Пример условной конструкции */

2018-04-27T21:45:03Z

‎Пример условной конструкции

Vidokq: /* Шаблонно-зависимые (pattern-specific) значения переменных */

2018-04-27T21:44:35Z

‎Шаблонно-зависимые (pattern-specific) значения переменных

Vidokq: /* Целе-зависимые (target-specific) значения переменных */

2018-04-27T21:44:17Z

‎Целе-зависимые (target-specific) значения переменных

Vidokq: /* Многострочные переменные */

2018-04-27T21:43:33Z

‎Многострочные переменные

Vidokq: /* Директива override */

2018-04-27T21:43:04Z

‎Директива override

Vidokq: /* Добавление текста к переменной */

2018-04-27T21:42:24Z

‎Добавление текста к переменной

@@ Строка 2146: / Строка 2146: @@
 Чаще всего, данное средство используется для передачи дополнительных опций компилятору. Например, в "правильно" написанном make-файле переменная CFLAGS используется при каждом вызове компилятора Си, так что исходный файл `foo.c' мог бы компилироваться приблизительно так:
-cc -c $(CFLAGS) foo.c
+ cc -c $(CFLAGS) foo.c
 Таким образом, значение, хранящееся в CFLAGS, будет влиять на любой процесс компиляции. Вполне возможно, что в make-файле определяется некоторое "обычное" значение для переменной CFLAGS, например:
-CFLAGS=-g
+ CFLAGS=-g
 Каждый раз, запуская make, вы, при желании, можете "перекрыть" это значение переменной CFLAGS. Например, при вызове `make CFLAGS='-g -O'', каждая компиляция будет осуществляться с помощью `cc -c -g -O'. (Этот пример также иллюстрирует, как вы можете включать пробелы и другие специальные символы в значение переменной при ее перекрытии.)

@@ Строка 1717: / Строка 1717: @@
 Вызов функции внешне напоминает ссылку на переменную. Он выглядит так:
-$(функция параметры)
+ $(функция параметры)
 или так:
-${функция параметры}
+ ${функция параметры}
 Здесь функция является именем функции. В make имеется некоторое количество "встроенных" функций. С помощью встроенной функции call вы можете определить свою собственную функцию.
-Параметры являются параметрами функции. От имени функции они отделяются одним или несколькими пробелами или символами табуляции. При наличии нескольких параметров, они отделяются друг от друга запятыми. Такие пробелы и запятые не рассматриваются как часть значения параметра. Разделители, которые вы использовали для обозначения вызова функции (круглые или фигурные скобки), могут появляться в аргументах только "попарно"; другие символы разделителей могут появляться и поодиночке. Если аргументы сами, в свою очередь, содержат ссылки на другие функции или переменные, для всех ссылок рекомендуется использовать один и тот же вид разделителей; то есть, например, писать `$(subst a,b,$(x))', а не `$(subst a,b,${x})'. Такая запись является не только более ясной, но и более "простой" для make (только один вид разделителей используется при поиске конца ссылки).
+Параметры являются параметрами функции. От имени функции они отделяются одним или несколькими пробелами или символами табуляции. При наличии нескольких параметров, они отделяются друг от друга запятыми. Такие пробелы и запятые не рассматриваются как часть значения параметра. Разделители, которые вы использовали для обозначения вызова функции (круглые или фигурные скобки), могут появляться в аргументах только "попарно"; другие символы разделителей могут появляться и поодиночке. Если аргументы сами, в свою очередь, содержат ссылки на другие функции или переменные, для всех ссылок рекомендуется использовать один и тот же вид разделителей; то есть, например, писать
 Перед тем, как аргумент будет передан для обработки в функцию, вычисляются все содержащиеся в нем ссылки на переменные и функции. Обработка аргументов производится в том порядке, как они перечислены.
@@ Строка 1729: / Строка 1730: @@
 Запятые и непарные скобки не могут "явным" образом появляться в аргументах функции; нельзя также "явным" образом указать наличии ведущих пробелов в первом параметре функции. Однако, эти символы могут быть вставлены в аргумент с помощью ссылки на переменные. Это можно сделать, определив, например, переменные comma и space, значениями которых будут, соответственно, одиночные символы запятой и пробела. Далее, значения этих переменных могут быть подставлены в любое место аргументов, где требуется наличие соответствующего символа. Например:
-comma:= ,
+ comma:= ,
-empty:=
+ empty:=
-space:= $(empty) $(empty)
+ space:= $(empty) $(empty)
-foo:= a b c
+ foo:= a b c
-bar:= $(subst $(space),$(comma),$(foo))
+ bar:= $(subst $(space),$(comma),$(foo))
-# bar is now `a,b,c'.
+ # bar is now `a,b,c'.
 Здесь, с помощью функции subst, каждый символ пробела, содержащийся в переменной foo, заменяется на символ запятой.

@@ Строка 1700: / Строка 1700: @@
 В следующем примере, в качестве завершающего шага пометки архивного файла как "обновленного", используется команда `ranlib -t':
-archive.a: ...
+ archive.a: ...
-ifneq (,$(findstring t,$(MAKEFLAGS)))
+ ifneq (,$(findstring t,$(MAKEFLAGS)))
          +touch archive.a
          +ranlib -t archive.a
-else
+ else
          ranlib archive.a
-endif
+ endif
 Префикс `+' помечает командные строки как "рекурсивные". Эти команды будут выполняться даже при наличии опции `-t'. Смотрите раздел Рекурсивный вызов make.

@@ Строка 1631: / Строка 1631: @@
 Синтаксис простой (без директивы else) условной конструкции выглядит следующим образом:
-условная-директива
+ условная-директива
-фрагмент-для-выполненного-условия
+  фрагмент-для-выполненного-условия
-endif
+ endif
 Фрагмент-для-выполненного-условия представляет собой последовательность любых строк текста, которые будут рассматриваться как часть make-файла, если проверяемое условие выполняется. В противном случае, этот текст не используется.
 Синтаксис "сложной" условной конструкции выглядит так:
-условная-директива
+ условная-директива
-фрагмент-для-выполненного-условия
+   фрагмент-для-выполненного-условия
-else
+ else
-фрагмент-для-невыполненного-условия
+   фрагмент-для-невыполненного-условия
-endif
+ endif
 При выполнении условия, используется фрагмент фрагмент-для-выполненного-условия; иначе, используется фрагмент фрагмент-для-невыполненного-условия. Фрагмент фрагмент-для-невыполненного-условия может содержать любое количество строк.
 Условная-директива имеет одинаковый синтаксис как в простой, так и в сложной условной конструкции. Имеется четыре разных директивы, проверяющих разные условия. Вот они:
-ifeq (параметр1, параметр2)
+ ifeq (параметр1, параметр2)
-ifeq 'параметр1' 'параметр2'
+ ifeq 'параметр1' 'параметр2'
-ifeq "параметр1" "параметр2"
+ ifeq "параметр1" "параметр2"
-ifeq "параметр1" 'параметр2'
+ ifeq "параметр1" 'параметр2'
-ifeq 'параметр1' "параметр2"
+ ifeq 'параметр1' "параметр2"
 Значения параметров параметр1 и параметр2 вычисляются и сравниваются между собой. При их совпадении используется фрагмент фрагмент-для-выполненного-условия; иначе используется фрагмент фрагмент-для-невыполненного-условия (если он имеется). Часто возникает необходимость проверить - содержит ли переменная какое-нибудь "непустое" значение. Трудность состоит в том, что после разного рода преобразований и вычислений функций, значение, выглядящее как "пустое", будет, на самом деле, состоять из пробелов и, таким образом, не будет считаться "пустым". Для того, чтобы избежать интерпретации пробелов как непустых значений, можно воспользоваться функцией strip (смотрите раздел Функции анализа и подстановки строк). В следующем примере:
-ifeq ($(strip $(foo)),)
+ ifeq ($(strip $(foo)),)
-фрагмент-для-случая-пустого-значения
+  фрагмент-для-случая-пустого-значения
-endif
+ endif
 фрагмент фрагмент-для-случая-пустого-значения будет использован даже в том случае, если значение переменной $(foo) будет состоять из пробелов.
-ifneq (параметр1, параметр2)
+ ifneq (параметр1, параметр2)
-ifneq 'параметр1' 'параметр2'
+ ifneq 'параметр1' 'параметр2'
-ifneq "параметр1" "параметр2"
+ ifneq "параметр1" "параметр2"
-ifneq "параметр1" 'параметр2'
+ ifneq "параметр1" 'параметр2'
-ifneq 'параметр1' "параметр2"
+ ifneq 'параметр1' "параметр2"
 Значения параметров параметр1 и параметр2 вычисляются и сравниваются между собой. Если они не совпадают, используется фрагмент фрагмент-для-выполненного-условия; иначе используется фрагмент фрагмент-для-невыполненного-условия (если он имеется).
-ifdef имя-переменной
+ ifdef имя-переменной
-Если переменная имя-переменной имеет непустое значение, будет использован фрагмент фрагмент-для-выполненного-условия; иначе, будет использован фрагмент фрагмент-для-невыполненного-условия (если таковой имеется). Переменные, которые еще не определены, рассматриваются как имеющие пустые значения. Обратите внимание, что директива ifdef просто проверяет - имеет ли переменная непустое значение. Она никогда не пытается вычислить это значение и проверить - не пустое ли оно. Как следствие, проверка с помощью ifdef будет возвращать "истину" для всех определений, кроме определений, подобных: foo =. Для проверки "вычисленного" значения переменной, используйте конструкцию ifeq ($(foo),). В следующем примере:
+Если переменная имя-переменной имеет непустое значение, будет использован фрагмент фрагмент-для-выполненного-условия; иначе, будет использован фрагмент фрагмент-для-невыполненного-условия (если таковой имеется). Переменные, которые еще не определены, рассматриваются как имеющие пустые значения. Обратите внимание, что директива ifdef просто проверяет - имеет ли переменная непустое значение. Она никогда не пытается вычислить это значение и проверить - не пустое ли оно. Как следствие, проверка с помощью ifdef будет возвращать "истину" для всех определений, кроме определений, подобных: foo =. Для проверки "вычисленного" значения переменной, используйте конструкцию
-bar =
+ifeq ($(foo),). В следующем примере:
-foo = $(bar)
+   bar =
-ifdef foo
+   foo = $(bar)
-frobozz = yes
+   ifdef foo
-else
+     frobozz = yes
-frobozz = no
+   else
-endif
+     frobozz = no
 переменная `frobozz' получит значение `yes', а в примере:
-foo =
+ foo =
-ifdef foo
+ ifdef foo
-frobozz = yes
+  frobozz = yes
-else
+ else
-frobozz = no
+  frobozz = no
-endif
+ endif
 переменная `frobozz' будет установлена в `no'.
 ifndef имя-переменной

@@ Строка 1589: / Строка 1589: @@
 В следующем примере, условная конструкция инструктирует make использовать разные наборы библиотек в зависимости от того, имеет ли переменная CC значение `gcc' или нет. Условная конструкция работает, управляя тем, какая из двух командных строк будет использоваться в качестве команды правила. В результате, при запуске make с параметром `CC=gcc' произойдет не только изменение используемого компилятора, но и изменение набора библиотек, с которыми будет компоноваться собираемая программа.
-libs_for_gcc = -lgnu
+ libs_for_gcc = -lgnu
-normal_libs =
+ normal_libs =
-foo: $(objects)
+ foo: $(objects)
-ifeq ($(CC),gcc)
+ ifeq ($(CC),gcc)
          $(CC) -o foo $(objects) $(libs_for_gcc)
-else
+ else
          $(CC) -o foo $(objects) $(normal_libs)
-endif
+ endif
 В этой условной конструкции используется три директивы: ifeq, else и endif.
@@ Строка 1609: / Строка 1609: @@
 Если переменная CC будет содержать значение `gcc', то приведенный выше пример будет работать как:
-foo: $(objects)
+ foo: $(objects)
          $(CC) -o foo $(objects) $(libs_for_gcc)
 При любом другом значении переменной CC, тот же пример будет работать как:
-foo: $(objects)
+ foo: $(objects)
          $(CC) -o foo $(objects) $(normal_libs)
 Аналогичного результата можно добиться, заключив оператор присваивания переменной нужного значения в условную конструкцию, и, затем, использовать эту переменную "безусловно":
-libs_for_gcc = -lgnu
+ libs_for_gcc = -lgnu
-normal_libs =
+ normal_libs =
-ifeq ($(CC),gcc)
+ ifeq ($(CC),gcc)
    libs=$(libs_for_gcc)
-else
+ else
    libs=$(normal_libs)
-endif
+ endif
-foo: $(objects)
+ foo: $(objects)
          $(CC) -o foo $(objects) $(libs)
 === Синтаксис условных конструкций ===

@@ Строка 1572: / Строка 1572: @@
 Шаблонно-зависимые переменные устанавливаются с помощью конструкции вида:
-шаблон ... : присваивание-переменной
+ шаблон ... : присваивание-переменной
 или:
-шаблон ... : override присваивание-переменной
+ шаблон ... : override присваивание-переменной
 где шаблон представляет собой шаблон с символом '%'. Подобно случаю задания целе-зависимых переменных, при указании сразу нескольких шаблонов, для каждого из них создается отдельный экземпляр шаблонного-зависимого значения. Присваивание-переменной может быть любой допустимой формой оператора присваивания. Как обычно, переменные, определенные через командную строку будут иметь "приоритет" если только не использовать директиву override.
 В следующем примере:
-%.o : CFLAGS = -O
+ %.o : CFLAGS = -O
 переменной CFLAGS будет присвоено значение `-O' при обработке всех целей, удовлетворяющих шаблону %.o.

@@ Строка 1550: / Строка 1550: @@
 Целе-зависимые значения переменных устанавливаются с помощью конструкции вида:
-цель ... : присваивание-переменной
+ цель ... : присваивание-переменной
 или:
-цель ... : override присваивание-переменной
+ цель ... : override присваивание-переменной
 При указании сразу нескольких целей, для каждой из них создается свое отдельное целе-зависимое значение.
@@ Строка 1562: / Строка 1562: @@
 Одна из особенностей целе-зависимых переменных заключается в следующем: когда вы определили целе-зависимую переменную, ее значение также будет "видно" для всех пререквизитов данной цели (конечно, если для пререквизитов не определены свои собственные целе-зависимые переменные). Так, например, в следующем выражении:
-prog : CFLAGS = -g
+ prog : CFLAGS = -g
-prog : prog.o foo.o bar.o
+ prog : prog.o foo.o bar.o
 переменная CFLAGS будет иметь значение `-g' во всех командах, выполняемых для цели `prog', а также (обратите внимание!) для целей `prog.o', `foo.o', `bar.o', и всех их пререквизитов.

@@ Строка 1512: / Строка 1512: @@
 На первой строке находится только название директивы (define), за которым следует имя переменной. Значение переменной указывается в следующих строках. Меткой конца значения переменной служит строка, содержащая единственное слово endef. За исключением синтаксических различий, директива define работает аналогично оператору `=', создавая рекурсивно вычисляемую переменную (смотрите раздел Две разновидности переменных). Имя этой переменной может содержать функции и ссылки на другие переменные, которые будут "вычислены" в момент чтения директивы define для нахождения действительного имени определяемой переменной.
-define two-lines
+ define two-lines
-echo foo
+  echo foo
-echo $(bar)
+  echo $(bar)
-endef
+ endef
 При использовании обычного оператора присваивания, значение переменной не может содержать символов перевода строки. При использовании же директивы define, символы перевода строки (за исключением символа, находящегося перед строкой с endef) становятся частью значения переменной.
 Предыдущий пример функционально подобен:
-two-lines = echo foo; echo $(bar)
+ two-lines = echo foo; echo $(bar)
 поскольку две команды, разделенные точкой с запятой работают во многом также, как и две отдельные команды. Заметьте, однако, что для команд, расположенных в двух отдельных строках, make будет вызывать командный интерпретатор дважды, запуская каждую команду в своей отдельной копии интерпретатора. Смотрите раздел Исполнение команд.
 Для переменных, определенных при помощи define, также может использоваться директива override. Как обычно, при ее использовании, определение переменной внутри make-файла будет иметь "приоритет" перед определением этой же переменной из командной строки:
-override define two-lines
+ override define two-lines
-foo
+   foo
-$(bar)
+   $(bar)
-endef
+ endef
 Смотрите раздел Директива override.

@@ Строка 1485: / Строка 1485: @@
 Если переменная была установлена при помощи командной строки (смотрите раздел "Перекрытие" переменных), то "обычное" присваивание ей нового значения внутри make-файла игнорируется. Если вы все-таки хотите присвоить подобной переменной новое значение, нужно использовать директиву override, выглядящую следующим образом:
-override переменная = значение
+ override переменная = значение
 или
-override переменная := значение
+ override переменная := значение
 При добавлении текста к переменной, определенной через командную строку, используйте конструкцию:
-override переменная += добавляемый-текст
+ override переменная += добавляемый-текст
 Смотрите раздел Добавление текста к переменной.
 Разумеется, директива override была придумана не для "экскалации войны" между make-файлом и параметрами командной строки. Идея заключалась в том, чтобы дать возможность изменять или дополнять передаваемые пользователем в командной строке значения.
-Предположим, вы хотите, чтобы компилятор Си всегда запускался с опцией `-g' и, в то же время, хотели бы дать пользователю возможность самостоятельно указать необходимые опции компиляции. Это можно сделать с помощью директивы override:
+Предположим, вы хотите, чтобы компилятор Си всегда запускался с опцией `-g' и, в то же время, хотели бы дать пользователю возможность самостоятельно указать необходимые опции компиляции. Это можно сделать с помощью директивы
+ override:
-override CFLAGS += -g
+ override CFLAGS += -g
 Директиву override можно также использовать совместно с директивой define. Выглядит это аналогично:
-override define foo
+ override define foo
-bar
+   bar
-endef
+ endef
 Смотрите следующий раздел, где описана работы директивы define.

@@ Строка 1441: / Строка 1441: @@
 Часто возникает необходимость добавить некоторый текст к значению уже определенной переменной. Вы можете это сделать с помощью оператора `+=', например:
-objects += another.o
+ objects += another.o
 Здесь, к значению переменной objects добавляется текст `another.o' (предваренный одиночным пробелом). Так, в результате выполнения фрагмента:
-objects = main.o foo.o bar.o utils.o
+  objects = main.o foo.o bar.o utils.o
-objects += another.o
+  objects += another.o
 переменная objects получит значение `main.o foo.o bar.o utils.o another.o'.
 Примерный аналог этого фрагмента без использования `+=' может выглядеть так:
-objects = main.o foo.o bar.o utils.o
+ objects = main.o foo.o bar.o utils.o
-objects := $(objects) another.o
+ objects := $(objects) another.o
 Однако, аналогия здесь не полная, поскольку работа оператора `+=' отличается некоторыми деталями, которые проявляются при работе с более сложными значениями переменных.
@@ Строка 1458: / Строка 1458: @@
 Когда вы что-либо добавляете с помощью `+=' к значению уже определенной переменной, make, по существу, действует так, как если бы этот дополнительный текст был включен в первоначальное определение переменной. Предположим, что переменная была ранее определена с помощью `:=' и является, вследствие этого, упрощенно вычисляемой переменной. Тогда, при добавлении к ней нового текста, оператор `+=' предварительно его "расширит" (аналогично тому, как это делает оператор `:='; смотрите раздел Установка значения переменной, где описана работа оператора `:='). Таким образом, фрагмент
-variable := value
+ variable := value
-variable += more
+ variable += more
 эквивалентен следующему:
-variable := value
+ variable := value
-variable := $(variable) more
+ variable := $(variable) more
 С другой стороны, при использовании оператора `+=' с рекурсивно вычисляемой переменной, make работает немного по-другому. Вспомните, что когда вы определяете подобную переменную, make не сразу вычисляет ссылки на функции и другие переменные, присутствующие в устанавливаемом для нее значении. Вместо этого, make запоминает указанный вами текст в "оригинальном" виде, так что все присутствующие в нем ссылки на переменные и функции остаются и могут быть вычислены позднее, когда переменная будет "раскрываться" (смотрите раздел Две разновидности переменных). Таким образом, при использовании оператора `+=' с рекурсивно вычисляемой переменной, указанный вами текст добавляется к "нераскрытому" значению, которое хранится внутри переменной. Поэтому, следующий фрагмент:
-variable = value
+ variable = value
-variable += more
+ variable += more
 примерно эквивалентен:
-temp = value
+ temp = value
-variable = $(temp) more
+ variable = $(temp) more
 (разумеется, на самом деле, никакой переменной temp не создается). Важность этого становится понятной при рассмотрении более сложных случаев, когда "старое" значение переменной содержит ссылки на другие переменные. Рассмотрим типичный пример:
-CFLAGS = $(includes) -O
+ CFLAGS = $(includes) -O
-...
+ ...
-CFLAGS += -pg # enable profiling
+ CFLAGS += -pg # enable profiling
 В первой строке этого примера определяется переменная CFLAGS, которая содержит ссылку на другую переменную с именем includes. (переменная CFLAGS используется в неявных правилах для компиляции программ на языке Си; смотрите раздел Перечень имеющихся неявных правил.) Использование оператора `=' определяет переменную CFLAGS как рекурсивно вычисляемую, и, значит, выражение `$(includes) -O' не будет вычисляться вв момент определения этой переменной. Таким образом, переменная includes совсем не обязана к этому времени быть определена. Достаточно, чтобы она была определена к тому моменту, когда будет вычисляться значение переменной CFLAGS. Если мы попробуем обойтись без оператора `+=', придется сделать что-нибудь, наподобие:
-CFLAGS := $(CFLAGS) -pg # enable profiling
+ CFLAGS := $(CFLAGS) -pg # enable profiling
 К сожалению, этот фрагмент работает не совсем так, как хотелось бы. Из-за использования оператора `:=' переменная CFLAGS становится упрощенно вычисляемой; это означает, что make "раскроет" выражение `$(CFLAGS) -pg' перед тем, как присвоить его переменной. Если переменная includes еще не была определена, в качестве результата "раскрытия" мы получим строку ` -O -pg', и последующее определение includes уже не сможет повлиять на этот результат. Напротив, при использовании `+=' в переменную CFLAGS запишется нераскрытое значение `$(includes) -O -pg'. Таким образом, мы сохраняем ссылку на переменную includes. Если переменная includes будет определена где-нибудь позднее, то ссылка на `$(CFLAGS)' будет использовать ее значение.