makepp_variables - Интернет в облаке

ПРОГРАММА:

ИМЯ

makepp_variables - Как использовать переменные в makepp

ОПИСАНИЕ

?: $ *,
$ +,
$ /,
$ <,
$ ?,
$ @,
$ ^,
=,
знак равно
знак равно
+ =,
знак равно
знак равно
знак равно A: АР,
АРФЛАГС,
В ВИДЕ, C: СС,
КФЛАГС,
"changed_dependencies",
измененные_входы,
КУРДИР,
СХХ,
CXXФЛАГИ, D: "зависимости",
"зависимость", F: F77,
ФК,
"для каждого", I: вход,
входы, L: ЛД,
ЛЕКС,
ЛИБТУЛ, M: СДЕЛАТЬ,
МАКЕСМДГОАЛС,
ДЕЛАТЬ ФЛАГИ,
СДЕЛАТЬИНФО,
MAKEPP_DEBUG,
СДЕЛАТЬ ФЛАГИ,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_квартира,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "вывод",
"выходы", P: ПЕРЛ,
инвалид, R: РМ,
КОРЕНЬ, S: ОБОЛОЧКА,
"sorted_dependencies",
отсортированные_входы,
"корень", T: цель,
цели, V: ВПУТЬ, Y: ЯАКК

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

Имена переменных чувствительны к регистру. Теоретически имена переменных могут состоять из многих
символов, но makepp, вероятно, не сможет его обработать, если вы сделаете что-нибудь кроме
буквенно-цифровые символы, «_» и «-».

Каждый make-файл имеет свой собственный набор переменных, и установка переменной в одном make-файле приведет к
не влияют на его значение в любом другом make-файле. Если вы хотите установить переменные в
много файлов makefile, лучший способ сделать это - включить в каждый из них общие определения
файл (см. оператор include) или используйте «глобальные» переменные.

Технология Назначение
Переменная может принимать значение несколькими способами:

· Переменная может быть установлена ​​внутри make-файла. Есть несколько способов сделать
это; увидеть ниже.

· Значение переменной может быть указано в командной строке, например:

makepp CFLAGS = -O2 моя_программа

Если загружено более одного make-файла, переменная CFLAGS распространяется на все
make-файлы. Переменные, установленные в командной строке, автоматически отменяют любые настройки
переменная в любом из make-файлов.

Если когда-либо понадобится, make-файл должен, в свою очередь, явно переопределить параметры командной строки.
Цель состоит не в том, чтобы игнорировать то, что запрашивает пользователь, а в том, чтобы изменить это.
Модификатор «override» может предшествовать любому оператору присваивания. Но в случае
операторы ключевых слов, порядок важен, поэтому вариант переопределения
всегда показано ниже. Модификатор "переопределить" применяется только к любым назначениям, в которых он
присутствует и не влияет на последующие присвоения переменной.

· Если в среде установлена ​​переменная, на нее можно ссылаться как на переменную makepp.
Обычно присвоение переменных внутри make-файла отменяет настройки из
environment, но вы можете изменить это, используя "-e" или "--environment-overrides"
командной строки.

Переменным присваивается одно из нескольких выражений присваивания, например это

X = 1
МОДУЛИ: = abcd
CC? = Gcc
CFLAGS + = -Стена
определить VAR
var строка 1
var строка 2
конечная защита
экспорт ПУТЬ: = $ (PWD): $ (ПУТЬ)
global MYPROJECT.INFO = информация, которая будет видна во всех make-файлах

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

Различные операторы присваивания имеют несколько разное значение.

просто назначение Операторы

=
ПЕРЕМЕННАЯ = текстовая строка
переопределить ПЕРЕМЕННАЯ = текстовая строка

Это обычный оператор присваивания, поддерживаемый всеми реализациями make. В
выражение в правой части не оценивается до тех пор, пока значение "$ (VARIABLE)" не будет
на самом деле где-то использовался. Таким образом, если вы сделаете следующее:

X = 1
Y = $ (X)
X = 2

Затем значение "$ (Y)" в make-файле будет равно "2".

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

:=
ПЕРЕМЕННАЯ: = выражение
переопределить ПЕРЕМЕННУЮ: = выражение

Это то же самое, что и "ПЕРЕМЕННАЯ = выражение", за исключением того, что вычисляется правая часть.
раз и навсегда во время задания. Таким образом, если

X: = 1
Y: = $ (X)
X: = 2

тогда "$ (Y)" позже в make-файле будет оцениваться как "1", поскольку это то, что было "$ (X)"
когда был определен "$ (Y)".

;=
ПЕРЕМЕННАЯ; = выражение
переопределить ПЕРЕМЕННУЮ; = выражение

Это то же самое, что и "ПЕРЕМЕННАЯ: = выражение", за исключением того, что вычисляется правая часть.
только на момент первого использования и потом вспомнил. Это полезно для дорогих
команды, которые всегда возвращают одно и то же значение, но которые вы не хотите выполнять, когда
построение несвязанных целей:

VAR1; = $ (дорогие вычисления perl)
VAR2; = $ (внешняя команда оболочки)

Обратите внимание, что старые make-файлы обычно используют здесь ": =", чтобы сделать это хотя бы один раз.
Но с этим оператором вы можете даже дополнительно этого не делать, если в данный момент вы этого не сделаете.
нужна ценность. Для значений, которые идентичны в нескольких каталогах, вы можете
оптимизировать это дальше с помощью «global», обсуждаемого ниже.

Однако это не задумано как умный способ принудительно установить порядок оценки. Если
переменная, определенная таким образом, включает значение другой переменной, и той другой
имеет конкретное целевое значение, и первое расширение предназначено для этой цели, затем
целевое значение будет сохраняться и для всех других контекстов. Это ошибка и
будем надеяться, что это будет исправлено в будущем.

+=
ПЕРЕМЕННАЯ + = выражение
переопределить ПЕРЕМЕННУЮ + = выражение

Добавляет строку к предыдущему содержимому переменной, разделенному пробелом. Если
переменная была ранее присвоена с помощью ": =", затем оценивается правая часть
перед добавлением.

&=
ПЕРЕМЕННАЯ & = выражение
переопределить ПЕРЕМЕННУЮ & = выражение

Добавляет строку к предыдущему содержимому переменной, разделенному пробелом.
Если переменная ранее была присвоена с помощью ": =", то правая часть будет
оценивается перед добавлением.

Например, один из способов гарантировать, что "CFLAGS", что бы еще ни вставил пользователь,
всегда начинается с "-Wall", это две строки:

CFLAGS = -O2 # Возможно переопределено в командной строке
переопределить CFLAGS & = -Wall # Безоговорочно добавляется в начало

В старых make-файлах вам обычно приходилось делать что-то вроде этого, у которого была сторона
эффект принуждения типа к ": =" для предотвращения бесконечной рекурсии:

ПЕРЕМЕННАЯ: = выражение $ (ПЕРЕМЕННАЯ)

?=
ПЕРЕМЕННАЯ? = Выражение
override VARIABLE? = expr # Бесполезно, но допустимо

Устанавливает значение переменной, но только если переменная не указана ранее в
make-файл, в командной строке или в среде. Вышеуказанное задание
в точности эквивалентно

ifndef ПЕРЕМЕННАЯ
ПЕРЕМЕННАЯ = выражение
ENDIF

!=
ПЕРЕМЕННАЯ! = Команда оболочки
переопределить ПЕРЕМЕННУЮ! = команду оболочки

Запускает команду оболочки и устанавливает переменную, содержащую стандартный вывод команды.
Это в точности эквивалентно

ПЕРЕМЕННАЯ: = $ (команда оболочки)

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

Оператор "define" является многострочным эквивалентом простых операторов, приведенных выше. В
оператор после переменной является необязательным. Если отсутствует, это эквивалентно «определить ПЕРЕМЕННУЮ.
= ". Операторы" & = "и" + = "здесь немного отличаются в том, что они связывают это с
старое значение с новой строкой, а не пробелом. Не должно быть ничего, кроме
комментарий после оператора, т.е. значение начинается со следующей строки.

определить ПЕРЕМЕННУЮ: =
первая строка значения переменной
вторая строка значения переменной
третья строка значения переменной
Endef

переопределить определение ПЕРЕМЕННОЙ
...
конечная защита

Ключевые слова перед словом "определить" могут быть комбинацией одного из "экспорт" или "глобальный" и
"переопределить".

Если вам нужно, чтобы значение переменной содержало символы новой строки, вы должны использовать оператор «определить» как
показано (или вы можете присвоить значение прямо в Perl). ("endef" был выбран для
совместимость с GNU make. Вы также можете использовать "enddef".) Это в первую очередь полезно для
"стандартные последовательности команд", например, что-то вроде этого:

определить COMPILE_C_PROGRAM
@ & echo "Компиляция $ (ввод)"
@ $ (CC) $ (CFLAGS) $ (CPPFLAGS) $ (ВКЛЮЧАЕТ) -c $ (ввод) -o $ (вывод)
Endef

Затем вы можете использовать эту многострочную переменную в нескольких правилах, например:

% .o:% .c
$ (COMPILE_C_PROGRAM)

$ (ARCH) /%. O: $ (ARCH) /%. C
$ (COMPILE_C_PROGRAM)

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

COMPILE_C_PROGRAM = @echo "Компиляция $ (ввод)"; \
$ (CC) $ (CFLAGS) $ (CPPFLAGS) $ (ВКЛЮЧАЕТ) -c $ (ввод) -o $ (вывод)

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

Есть одна особенность при расширении внутри "define", то есть "define X: =" или на
переменная, которая уже была ": =", "определить X & =" и "определить X + =". В этом случае
«$ (команда оболочки ...)» или встроенный «$ (& command ...)» не преобразуют символы новой строки в
пространства.

Экспорт переменные в подпроцессы

экспорт VAR ...
экспорт VAR = значение
переопределить экспорт VAR + = значение

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

разделение переменные через Makefiles

глобальный VAR ...
global VAR = значение
переопределить глобальную переменную & = значение

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

Вторая форма, которая применяется только к одной переменной, дополнительно присваивает значение право
прочь. Допускаются все варианты присвоения. Обратите внимание, что ": =" сразу же развернется
значениям в локальном make-файле. Напротив, переменные "=" будут заменены на
значения в момент использования.

С глобальными переменными может быть сложно работать, потому что makepp может загружать make-файлы в любой
порядок, поскольку возникает необходимость создать некоторую цель, для которой не загружаются правила или файлы сборки.
По этой причине рекомендуется иметь RootMakeppfile и явно загрузить все
другие, которые изменяют или используют переменную с "load-makefile".

global GLIBLIBS; = $ (оболочка pkg-config --libs glib-2.0)

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

Целевой Назначения

цель: ПЕРЕМЕННАЯ = строка
цель: ПЕРЕМЕННАЯ: = строка
цель: переопределить ПЕРЕМЕННУЮ + = строка

Устанавливает целевое значение переменной. Действует целевое значение только
в действии, которое производит данную цель. Это в основном используется для таких вещей, как
это:

CFLAGS: = -O2

my_prog: файл1.о файл2.о специальный_файл.о

специальный_файл.o: CFLAGS: = -g

% .o:% .c
$ (CC) $ (CFLAGS) -c $ (ввод) -o $ (вывод)

Здесь происходит то, что все файлы ".c" будут скомпилированы с оптимизацией ("-O2") кроме
"special_file.c", который компилируется в режиме отладки ("-g"). Это удобный способ
указать разные параметры компиляции только для нескольких файлов.

Подобные назначения переменных для конкретных целей применяются только к действиям правила; Oни
не действуют при оценке целей или зависимостей правила. Если правило
имеет более одной цели, назначения переменных для конкретных целей берутся только из
первый цель. Также обратите внимание, что переменные, специфичные для цели makepp, немного отличаются
от GNU make в том, что они применяются только к правилу для одного упомянутого файла, а не к
любой из его предшественников.

Расширение подстановочных знаков выполняется для цели, поэтому вы можете сделать что-то вроде этого:

тест _ *. o: CFLAGS + = -DTEST

Для совместимости с GNU make вместо «*» можно использовать «%».

Технология подмена
Правила замены переменных Makepp аналогичны правилам других производителей, но в некоторой степени
более могущественный. Как и во всех марках, "$ (CC)" или "$ {CC}" оба представляют ценность
переменная CC. Если вам нужен буквальный знак доллара, поставьте двойной знак доллара ($$), например
это:

цель: деп1 деп2 деп3 деп4
& rm -f $ (вывод)
для файла в $ (входы); сделать cat $$ file >> $ (вывод); Выполнено

Кроме того, makepp имеет синтаксис "$ [VARIABLE]", который делает то же самое, что и другие
два, но до того, как makepp попробует что-нибудь еще. Это позволяет использовать его для полных правил
и / или условные:

определить скобку_rule =
если определить SOME_VAR
скобка:
& echo это правило -o $ (вывод)
ENDIF
конечная защита

$ [квадратное_правило]

RC-стиль замена

По умолчанию makepp использует подстановку в стиле rc (названную так, потому что она была впервые введена в
RC-оболочка). Лучше всего это проиллюстрировать на примере:

МОДУЛИ = abcd

mylib.a: каталог_модулей / $ (МОДУЛИ) .o $ (ДРУГИЕ_ОБЪЕКТЫ)
$ (CXX) $ (зависимости) -o $ (цель)

К каждому слову в MODULES добавляется префикс «каталог_модуля /», а суффикс «.o» -
добавляется к каждому слову.

Вы также можете использовать замену в стиле rc, даже не помещая список слов в
Переменная; синтаксис: «$ (слово1 слово2)». Обратите внимание на пробел между круглыми скобками и
первое слово. Таким образом, приведенный выше пример можно было бы записать как:

mylib.a: каталог_модуля / $ (abcd) .o $ (OTHER_OBJECTS)
$ (CXX) $ (зависимости) -o $ (цель)

Переменная выполнит замену в стиле rc, только если в ней более одного слова.
Одним словом, это как традиционная марка. Увы, когда переменная пуста, есть
конфликт. Традиционные методы просто расширяют его до пустой строки. Но когда вы думаете о
это как список, вы бы хотели, чтобы "-I $ (DIRLIST)" исчезал, а не отображался одинокий "-I". В
решение состоит в том, чтобы обернуть его в список, который начинается с пробела: "-I $ ($ (DIRLIST))" дает вам
ровно столько вариантов, сколько слов в списке.

Если вы поместите несколько переменных в одно слово, которое расширяется до массивов слов, rc-style
подстановка фактически берет декартово произведение, поэтому вы можете сделать что-то вроде этого, если
ты хочешь:

DIRS = s1 s2
МОДУЛИ = abc
СУФФИКСЫ = .o .c
ФАЙЛЫ: = $ (КАТАЛОГИ) / $ (МОДУЛИ) $ (СУФФИКСЫ)

а ФАЙЛЫ будут содержать строку

s1 / ao s1 / ac s1 / bo s1 / bc s1 / co s1 / cc s2 / ao s2 / ac s2 / bo s2 / bc s2 / co s2 / cc

Помимо пробелов, подстановка в стиле rc останавливается на любой кавычке, любой круглой, фигурной или квадратной.
круглые скобки и любые из ",:; = # @". Обратите внимание, что это может показаться неожиданным, и снова потребуется
явный список. Скажем, вы хотите искать заголовки по шаблону во всех каталогах
начиная с заглавной буквы:

ПЛОХО: = [AZ] * / ** / *. $ (Hpp h) # [AZ] * / ** / *. Hpp * / ** / *. H
ХОРОШО: = $ ([AZ] * / ** / *.) $ (Hpp h) # [AZ] * / ** / *. Hpp [AZ] * / ** / *. H

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

цель: makepp_simple_concatenation = 1
цель:
& echo before_first $ (СПИСОК) after_last -o $ (вывод)

Поскольку "$ [VARIABLE]" вычисляется раньше, чем "$ (VARIABLE)", объединение двух в rc-
подстановка не даст ожидаемого результата, если вы не заключите ее в явный
список:

A = ab
Н = 1 2
ПЛОХО: = $ (A) $ [N]
ХОРОШО: = $ (A) $ ($ [N])

Последние строки читаются как

ПЛОХО: = $ (A) 1 2 # a1 b1 2
ХОРОШО: = $ (A) $ (1 2) # a1 a2 b1 b2

подмена Рекомендации

Ссылка на замену имеет форму "$ (VAR: A = B)", где A - шаблон для сопоставления, а B -
шаблон для его замены. Ссылки на замену - это аббревиатура для
функция "пацубст". Например:

source_files = ac bc cc dc
object_files = $ (исходные_файлы:%. c =%. o)

установит "$ (object_files)" в "ao bo co do". "%" - это специальный символ, соответствующий
любая произвольная строка. Если и A, и B начинаются с "%", это обычный случай при замене
суффиксы, их можно не указывать:

файлы_объектов = $ (файлы_источников: .c = .o)
object_files = $ (source_files: c = o) # то же самое, потому что. не особенный

Пробелы in переменные

Если вам нужно контролировать пробелы в переменной, вы должны (в настоящее время) отключить rc-style
подстановка (установив makepp_simple_concatenation = 1), а затем используйте такой синтаксис:

ноль =
T = -o $ (ноль)

или с пустой оценкой:

Т = -o $ ()

Когда вы это сделаете, переменная «T» будет содержать «-o», за которым следует пробел.

Такой метод обработки пробелов не рекомендуется. Если вам нужны переменные
в вашем make-файле, чтобы содержать пробелы, вы должны серьезно подумать о том, что вы делаете.
Если вам нужно обрабатывать пробелы, обычно гораздо лучше поместить код Perl в ваш
makefile, чтобы позаботиться об этом (используя операторы perl_begin или sub) или обработать его
в операторах оболочки в действиях правил.

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

ifeq ($ (ARCH), чудак)
O: = / ВЫХОД =
еще
null: =
O: = -o $ (ноль)
ENDIF

% .o:% .c
$ (КОМПИЛЯТОР) $ (ввод) $ (O) $ (вывод)

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

ifeq ($ (ARCH), чудак)
% .o:% .c
$ (WEIRD_COMPILER) $ (вход) / OUTPUT = $ (выход)
еще
% .o:% .c
$ (CC) -c $ (ввод) -o $ (вывод)
ENDIF

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

Автоматический Переменные
Автоматические переменные - это переменные, которые принимают разные значения в зависимости от того, какое правило
они оцениваются в. Makepp поддерживает большинство автоматических переменных, которые другие
версии использовать. Кроме того, для большинства из них в нем менее загадочные и длинные названия.
что вы можете использовать вместо этого. (Для устаревших make-файлов, которые переопределяют эти имена,
определение в make-файле отменяет значение по умолчанию. Например, если вы скажете
"target = abc" в вашем файле makefile, тогда "$ (target)" всегда будет расширяться до "abc" и не будет
длиннее эквивалентно $ @.)

Ниже приводится полный список всех автоматических переменных, которые поддерживает makepp:

выходной
цель
$ @ Цель текущего правила. На самом деле, поскольку makepp поддерживает несколько целей для
любое правило, это первый цель. Например, в следующем правиле

y.tab.c y.tab.h: parser.y
$ (YACC) -o $ (вывод) $ (YFLAGS) $ (ввод)

"$ (вывод)" будет содержать значение y.tab.c. Поскольку эти магические переменные на самом деле
функции, вы также можете передать индекс в качестве аргумента. Считается от 1 или наоборот.
от 1. Таким образом, «$ (вывод 2)» или «$ (вывод -1)» будет содержать значение y.tab.h.

Хотя все три формы этой переменной имеют одинаковое значение, есть разница в
интерпретация многосторонних правил. Если вы используете загадочное имя в старом стиле $ @,
makepp будет интерпретировать это как набор правил старого стиля, а не как современное правило, которое
производит все эти цели за один раз:

ab: # на самом деле: по одному правилу для a и b
коснитесь $ @

cd: # error: mpp жалуется, что это не построило d
коснитесь $ (вывод)

выходы
направлена против
Все цели текущего правила. То же, что и "$ (target)", если только их не более одного
цель. В приведенном выше примере «$ (output)» будет y.tab.c y.tab.h. Вы можете пройти
список индексов, поэтому "$ (output 2 1)" будет y.tab.h y.tab.c.

зависимость
вход
$ <Первая явная зависимость правила. Например, в этом правиле

% .o:% .c
$ (CC) $ (CFLAGS) -c $ (ввод) -o $ (вывод)

"$ (input)" будет именем .c файл, независимо от того, какой .h файлы makepp
обнаруживает. Если вы укажете более одной зависимости, вы можете получить их, передав
index: «$ (input $ (INDEX))» - это зависимость INDEX.

Зависимости
затраты
$ ^ Все явные зависимости цели, кроме .h файлы, обнаруженные
makepp_scanning для включает.

Например, в правиле

myprog.o: * .o
$ (CC) $ (CFLAGS) $ (входы) -o $ (выход)

«$ (input)» - это все файлы .o в каталоге. Вы можете выбрать только те, которые вы
хотите, передав список индексов. Если вы явно укажете разные типы файлов,
вы можете выбрать их, как в "$ (inputs 2 3 4)" (но с подстановочным знаком это не слишком
перспективный).

сортированные_зависимости
sorted_inputs
$ + Все зависимости цели в отсортированном порядке с удаленными дубликатами.
Эквивалентно «$ (sort $ (inputs))».

измененные_зависимости
измененные_входы
$? Изменившиеся зависимости цели. Сюда входят только явные
зависимости (то есть те, которые вы перечисляете в make-файле), неявно обнаруженные
зависимости от сканирования (например, файлы .h).

Обычно это используется в таких командах:

libmine.a: $ (МОДУЛИ): build_check ignore_action
$ (AR) ru $ @ $?

т.е. ar предлагается заменить только те модули, которые были изменены. (Обратите внимание
Правило проверки сборки ignore_action. Если вы не укажете это, makepp заставит
действие, которое будет выполняться всякий раз, когда оно изменяется. Если зависимости не изменились,
строка действия будет "ar ru libmine.a", что, вероятно, отличается от того, что было
в прошлый раз, когда вы запускали его, makepp выполнит его без "ignore_action". В этом
В этом случае это безвредно, но с другими командами это может быть проблемой. Видеть
makepp_build_check для получения подробной информации о "ignore_action".)

Создание таких архивов - не лучшая идея, потому что это сделает ваши сборки меньше
надежный. Проблема в том, что если вы собираете архив, то удалите один из
модули из списка МОДУЛЕЙ, модули останутся в архиве и
макияж

стебель
$ * Основа в шаблоне правила (т. Е. Независимо от того, что соответствует "%"). В качестве альтернативы, если это
не является шаблонным правилом, возвращает имя файла без расширения (т. е.
эквивалентно «$ (базовое имя $ (вход))».

Это в основном для обратной совместимости. Например, в старых версиях сделать
единственный способ сказать, как скомпилировать любой .c файл в соответствующий .o файл был похож
это:

.co:
$ (CC) $ (CFLAGS) -c $ *. C -o $ *. O

Это паршивый способ написать правило. Намного понятнее использовать стиль GNU-make
правила шаблона, например:

% .o:% .c
$ (CC) $ (CFLAGS) -c $ (ввод) -o $ (вывод)

Еогеасп
Текущее имя файла из предложения foreach. предложения foreach используются редко,
но они являются наиболее универсальным типом шаблонных правил, которые поддерживает makepp. За
пример,

#
# Создайте файлы .c с помощью специального препроцессора:
#
% .c:% .k
$ (препроцессор) $ (ввод)> $ (вывод)

#
# Скомпилировать файлы .c в файлы .o:
#
% .o:% .c
$ (CC) $ (CFLAGS) -c $ (ввод) -o $ (вывод)

#
# Специальные альтернативные флаги компиляции для файлов .c, которые являются производными
# из файлов .k:
#
$ (foreach:%. k =%. o): $ (foreach:%. k =%. c): foreach * .k
$ (CC) $ (SPECIAL_K_FLAGS) -c $ (ввод) -o $ (вывод)

См. Документацию по предложению foreach в правилах для получения дополнительных сведений и примеров.

$ / По сути, это константа, либо "/", либо "\" в родной Windows. Вам это нужно, если
вы хотите запустить переносимую программу, например, созданную в текущем каталоге:

мой вывод:
. $ / myprog> $ (вывод)

Для имен файлов, переданных в качестве аргументов, это не так необходимо, поскольку Windows может обрабатывать Unix.
синтаксис есть.

Опция Переменные
Вы можете установить их всеми способами, описанными выше (если не указано иное), чтобы изменить
поведение makepp. По умолчанию все они не определены.

MAKEPP_DEBUG
Если вы экспортируете это с истинным значением перед вызовом makepp, вы получите больше отладки
Информация. Это «RULE_SOURCE» файлов, созданных, пока он действует под
makeppinfo, mppi и подробности о расширении переменных и сопоставлении правил в
makepplog, mppl. Это также покажет вам, если makepp не хватает памяти или зависает,
потому что он бесконечно расширяет одни и те же переменные:

A = $ A # отложенная оценка, необходимо: =
B = $ C
C = $ B

MAKEPP_LN_CP
См. Примечание под & ln.

makepp_percent_subdirs
Установите для него какое-нибудь истинное значение (например, 1), чтобы "%" в целях или зависимостях соответствовал.
в более чем одном каталоге.

makepp_require_phony
Установите для него некоторое истинное значение (например, 1), чтобы предотвратить неявную фальшивость (т.е. если правило
преуспевает, не производя своей цели). По умолчанию эта переменная должна иметь значение true, чтобы
предотвратить разорванные цепочки зависимостей, но это нарушит обратную совместимость с
небрежные make-файлы.

makepp_signature_C_flat
Это вариант для подписи C. Установите для него какое-нибудь истинное значение (например, 1), чтобы лечить
источники как сглаженные, т.е. все символы новой строки (кроме операторов препроцессора) являются
обрабатываются как пробелы и директивы "#line" игнорируются.

makepp_simple_concatenation
Установите для него какое-нибудь истинное значение (например, 1), чтобы предотвратить "подстановку в стиле rc".

PERL
Вы можете установить это на тот Perl, который вы используете для запуска скриптов в makepp.
Suite и экспортируйте его. Это может помочь запустить подпрограммы с тем же perl. Это
в основном полезен для набора тестов, установки и для рекурсивных сборок.

ВПУТЬ
Установка для этой переменной некоторого значения неявно вызывает "vpath% value".

предопределенный Переменные
Makepp предопределяет несколько переменных, которые вы можете переопределить:

AR По умолчанию: "ар".

АРФЛАГС
По умолчанию: "rv".

AS По умолчанию: "в виде".

CC По умолчанию: Первые найдены среди «gcc», «egcc», «pgcc», «c89» или «cc» или в Windows.
дополнительно "cl" или "bcc32".

КФЛАГИ
По умолчанию: Если «$ (CC)» является компилятором GNU «-g -Wall», если это одна из двух Windows
ничего не компилирует, остальное "-g".

ТВОРЕЦ
Каталог, в котором находится текущий Makefile.

СХХ По умолчанию: Первые найдены среди "g ++", "c ++", "pg ++", "cxx", "C", "C" или "aCC" или на
Windows дополнительно "cl" или "bcc32".

CXXFLAGS
По умолчанию: Если "$ (CXX)" является компилятором GNU "-g -Wall", если это одна из двух Windows
ничего не компилирует, остальное "-g".

F77 По умолчанию: Первые встречаются среди «f77», «g77» или «fort77».

FC По умолчанию: «$ (F77)».

LD По умолчанию: "ld".

LEX По умолчанию: Первый встречается среди «lex» или «flex».

ЛИБТУЛ
По умолчанию: "libtool".

ДЕЛАТЬ
Эта переменная имеет два разных значения в зависимости от наличия или отсутствия
"--traditional-recursive-make". Makepp распознает, когда эта переменная используется, и
отключает некоторые функции даже до того, как действительно произойдет рекурсия. Это может быть
нежелательно, пока вы постепенно устраняете его, поэтому сначала преобразуйте вызовы в
makepp специфический "$ ((MAKE))", который не отключает функции. Вы не должны устанавливать это
потому что это нарушает нашу работу интеллектуальной рекурсии.

МАКЕСМДГОАЛС
Эта переменная установлена, но не используется makepp. Вы можете запросить его, чтобы он что-то сделал, только если
была запрошена определенная цель.

По умолчанию: Независимо от того, что явное нацелено на пользователя (или рекурсивный вызов), предоставленное.
Пусто при неявном построении цели по умолчанию.

ifneq $ (специальная цель фильтра, $ (MAKECMDGOALS))
# special-target - одна из текущих явных целей
иначе ifeq $ (MAKECMDGOALS)
# нет явных целей
ENDIF

MAKEFLAGS (экспорт)
Стандартные опции, с которыми вызывается makepp. Те, у которых одна буква
формы объединяются в начале без ведущего "-" (бог знает, почему gmake выбрал
опустить "-").

СДЕЛАТЬИНФО
По умолчанию: "makeinfo".

MAKEPPFLAGS (на экспорт)
Устанавливается то же значение, что и MAKEFLAGS, но только если эта переменная присутствует в
Среда makepp.

_MAKEPPFLAGS (экспортировано)
Специальные параметры makepp, необходимые для совместимости с POSIX / gmake, с которыми makepp
назывался. Они находятся в отдельной переменной, поэтому устаревший make-файл не может сломаться.
совместимость, отключив MAKEFLAGS. Это устанавливается только с
"--traditional-recursive-make".

MAKEPP_VERSION
Версия makepp, с которой вы работаете. Если это бета-версия, у нее будет
дефис, за которым следует ГГММДД плюс еще несколько внутренних данных. Вы можете использовать это для "ifdef"
чтобы скрыть определенные конструкции makepp от других производителей.

По умолчанию: То же значение отображается в "makepp --version"

PWD Псевдоним для "CURDIR".

RM По умолчанию: "rm -f". Это предназначено для устаревших файлов Makefile. Для новых желательно использовать
напрямую встроенную команду & rm. Если вы хотите написать фальшивое правило очистки, посмотрите на
вместо этого используйте команду "makeppclean -r".

ROOT
Относительный путь к корню вашей системы сборки, то есть к каталогу выше в
который у вас есть "RootMakeppfile (.mk)". Если у вас его нет, эта переменная
пустой.

SHELL
Эта переменная соблюдается только в том случае, если вы ее «экспортируете». В этом случае это Shell
который используется для выполнения не встроенных действий с некоторым специальным символом в нем (простой
те, которые выполняются напрямую). В Windows Strawberry или ActiveState Perl, если у вас есть
Unix-подобную оболочку, вместо этого вы должны установить для переменной SHELL значение, оканчивающееся на "sh"
или "sh.exe" до вызов makepp.

По умолчанию: Первый найденный среди "/ usr / xpg4 / bin / sh" (например, Solaris) или "/ sbin / xpg4 / sh"
(например, Reliant Unix) или "/ Бен / ш".

ЯАКК
По умолчанию: Первые встречаются среди «зубров-у» или «яцк».

Переменные и Perl
Значения переменных хранятся как обычные скаляры Perl, поэтому вы можете получить к ним доступ прямо из
Код Perl, если вам нужно проделать с ними какие-либо сложные манипуляции; см. makepp_exnding
для получения информации.

Доступ к глобальным переменным из Perl достигается с помощью префикса «Mpp :: global».
упаковка. Фактически, любая переменная, еще не представленная в текущем make-файле, и которую вы
assign to в этом пакете с этого момента будет глобальным, как если бы вы только что выпустили
"глобальное" заявление для него.

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

При прямом доступе вы также обойдете раскрытие этих переменных, если они имеют тип
«=» или «; =». Специальные переменные, такие как "$ (CC)", начинаются как функции, пока не станут
назначен. Так что во многих случаях вы не увидите их ценности.

По этим причинам лучше позволить makepp определить правильное значение. Вы можете использовать
вариант "makeperl", в котором переменная была оценена до того, как код Perl получит
интерпретируется:

makeperl {$$ current_value = '$ (MAKEFILE_VAR)'}

Если вам нужна переменная в perl-блоках make-файла, это достигается с помощью переменной Perl.
$ makefile следующим образом:

perl {$ current_value = $ makefile-> expand_variable ('MAKE_VAR')}

Функции всегда получают объект makefile, переданный в качестве второго аргумента $ _ [1]:

sub f_f {$ current_value = $ _ [1] -> expand_variable ('MAKE_VAR')}

Команды должны вызываться внутри действия правила, где объект makefile
доступно через "$ Mpp :: Subs :: rule -> {MAKEFILE}":

sub c_cmd {$ current_value = $ Mpp :: Subs :: rule -> {MAKEFILE} -> expand_variable ('MAKE_VAR')}

Используйте makepp_variables в Интернете с помощью сервисов onworks.net