makepp_functions - Онлайн в облаке

ПРОГРАММА:

ИМЯ

makepp_functions - Функции в makepp

ОПИСАНИЕ

A: абсолютное_имя_файла,
абсолютное_имя_файла_nolink,
абспат,
добавитьпрефикс,
добавляет суффикс,
а также, B: базовое имя, C: вызов, D: реж
дир_нослэш, E: ошибка, F: файл,
фильтр,
отфильтровано,
filter_out_dirs,
найти файл,
найти_first_upwards,
найти_программа,
findstring
найти_вверх,
первый_доступный,
первое слово,
для каждого, I: если,
если правда,
вывод_линкер,
вывести_объекты,
Информация, J: присоединиться, M: делать,
макияж,
мейкперл,
карта,
"мктемп", N: нодир, O: только_сгенерированный,
только_нецели,
only_phony_targets,
только_устаревший,
только_цели,
или,
происхождения, P: пацубст,
Perl,
фальшивый
предварительная сборка,
Распечатать, R: реальный путь
относительное_имя_файла,
относительно, S: ракушка,
Сортировать,
полоса,
подстановка,
суффикс, T: временный, W: предупреждение,
подстановочный знак
слово,
список слов,
слова, X: xargs

Любое выражение формата «$ (имя)», где «имя» не является именем переменной, или
«$ (имя arg1 arg2 arg3)» интерпретируется как вызов функции. Имя может содержать буквы,
подчеркивания или дефисы; чтобы избежать путаницы, вы можете использовать дефисы или символы подчеркивания
взаимозаменяемо, поскольку внутренние дефисы преобразуются в символы подчеркивания. Оценивая такие
выражение просто вызывает подпрограмму Perl. Если перед «именем» стоит «&», запускается
встроенная команда или сценарий с таким именем в процессе makepp и возвращает стандартный
выход. Это требует, чтобы Perl был построен для PerlIO. Если имя не называет функцию
он трансформируется в призыв вызова.

Как и в случае с переменными, у вас есть выбор «$ (имя ...)» или «$ {имя ...}». Если хотите
вставьте одну и ту же круглую скобку, она должна быть парной, другая не имеет значения: "$ (name
... () {... "или" $ {name ... {} (...} ". (Однако для map и perl первая закрывающая скобка заканчивается
выражение.) Удвоение позволяет аргументам занимать несколько строк. Новые строки
затем обрабатываются как пробелы, кроме, может быть, в "define". Также есть синтаксис «$ [имя ...]»
или $ [[name ...]], который вычисляется при чтении make-файла, перед проверкой правил
и другие конструкции.

Makepp имеет ряд встроенных функций, которые могут быть полезны. Он поддерживает почти все
Текстовые функции GNU make (подробности см. В документации GNU make), а также некоторые из ее
собственный. Вы можете определить подпрограммы Perl, чтобы они делали все, что захотите. См. "Под" заявление
и раздел о расширении makepp для получения более подробной информации.

Условный функции
и условие1 [, условие2 [, условие3 ...]]
Функция and обеспечивает операцию "короткого замыкания" И. Каждый аргумент
расширен, по порядку. Если аргумент расширяется до пустой строки, обработка останавливается и
результат раскрытия - пустая строка. Если все аргументы расширяются до не-
пустая строка, то результатом раскрытия будет раскрытие последнего аргумента.

if строка, результат-если-строка-не-пустая [, результат-если-строка-пустая]
если правда строка, результат-если-строка-истина [, результат-если-строка-ложь]
Альтернатива утверждениям ifeq и т. Д. Если строка не пуста (т. Е.
условие истинно), второй аргумент (предложение "then") возвращается (после
расширение переменных); если строка пуста, третий аргумент (предложение "else") будет
вернулся.

Например,

CFLAGS: = $ (если $ (фильтр gcc egcc, $ (CC)), -g -Wall, -g)

определяет CFLAGS как «-g -Wall», если переменная CC имеет значение «gcc» или «egcc», и «-g»
иначе. (Это то, что делают правила сборки по умолчанию.)

«iftrue» аналогично «if», за исключением того, что строка 0 рассматривается как пустая.

or условие1 [, условие2 [, условие3 ...]]
Функция или обеспечивает операцию «короткое замыкание» ИЛИ. Каждый аргумент раскрывается,
чтобы. Если аргумент расширяется до непустой строки, обработка останавливается и
результатом раскрытия является эта строка. Если после раскрытия всех аргументов все
они ложны (пусты), тогда результатом раскрытия будет пустая строка.

Файл и Имя файла функции
абсолютное_имя_файла файлов
абспат файлов
Преобразует относительные имена файлов в абсолютные без . or .., Например,
«$ (absolute_filename xyz.c)» может вернуть «/usr/src/our_project/subdir/xyz.c».

абсолютное_имя_файла_nolink файлов
реальный путь файлов
Подобно absolute_filename, но обеспечивает разрешение символьных ссылок.

базовое имя имена файлов
Базовое имя - это полное имя файла (с каталогом) за вычетом текста после и
включая последний период. Например, "$ (базовое имя myfile / version-1.0-module.c)" равно
"myfile / версия-1.0-модуль"

директория имена файлов
Извлекает часть каталога каждого файла в списке файлов, включая конечный
слэш. Возвращает "./", если в имени файла нет каталога.

dir_noslash имя файла
То же, что и "$ (dir)", за исключением того, что не возвращает косую черту в конце.

Filesubst шаблон, заменять, слова
Выполните замену шаблона в именах файлов. Это отличается от пацубста тем, что
он будет работать правильно, если даны альтернативные имена для каталогов (до тех пор, пока
они предшествуют знаку процента). Например,

$ (filesubst ./src/%.c,% .o, $ (подстановочный знак src / *. c))

будет работать с filesubst, но не с patsubst.

filter_out_dirs имена файлов
Возвращает все имена файлов, которые не относятся к каталогам.

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

TCL_INCLUDE: = -I $ (dir_noslash $ (findfile tcl.h, \
/usr/local/stow/tcl-8.4.5-nothread/include \
/usr/include/tcl8.4 / usr / include / tcl \
/net/na1/tcl8.4a3/include /net/na1/tcl8.4a3/include))

Это находит файл tcl.h путем поиска во всех вышеуказанных каталогах. Абсолютный
путь к файлу возвращается. Затем "$ (dir_noslash)" извлекает этот каталог и
помещается в путь включения.

найти_программа имя
Вернуть первую программу в списке, который можно найти в ПУТЬ. Это полезно
когда можно использовать несколько эквивалентных программ, и вы просто хотите
выберите один из них. Например, вот определение по умолчанию нескольких общих
переменные, которые предоставляет makepp, если вы не поместили их в свой make-файл:

CC = $ (find_program gcc egcc pgcc c89 cc) # и другие, в зависимости от машины
F77 = $ (find_program f77 g77 fort77)
CXX = $ (программа поиска g ++ c ++ pg ++ cxx CC aCC)

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

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

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

find_upwards имя файла
Ищет файл с заданным именем в каталоге., .., ../ ..../../ ..И т.д.
пока файл не будет найден, или пока не будет достигнут корневой каталог, или пока не будет найден каталог.
в другой файловой системе. (Последнее требование - предотвратить проблемы с
автомонтирования или зависших сетевых файловых систем.) Если у вас есть RootMakeppfile, это тоже
барьер, препятствующий поиску выше.

Например, если у вас есть проект с множеством уровней подкаталогов, вы можете
включить этот общий фрагмент во все make-файлы (например, используя "include"
утверждение):

TOP_LEVEL_INCLUDE_DIR: = $ (find_upwards включает)
# Ищет каталог, содержащий
# включает подкаталог.

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

Другая проблема, которую может решить "find_upwards", - это поиск каталога верхнего уровня.
постройки. Часто бывает полезно определить такую ​​переменную:

TOP: = ../../ ..

если у вас есть важная информация, расположенная только в каталоге верхнего уровня. Но
это сложно поддерживать, потому что количество ".." разное для разных уровней
дерева каталогов. Вместо этого вы можете использовать "find_upwards", чтобы найти файл, который
известно, что он присутствует только в каталоге верхнего уровня. Предположим, например, что
файл «ЛИЦЕНЗИЯ» находится только в каталоге верхнего уровня. Тогда вы могли бы сделать это:

TOP: = $ (dir_noslash $ (ЛИЦЕНЗИЯ find_upwards))

«$ (find_upwards LICENSE)» возвращает полный путь к файлу лицензии;
«$ (dir_noslash ...)» удаляет имя файла, возвращая только каталог.

(Обратите внимание, что оператор "include" автоматически ищет файлы вверх, поэтому там
нет необходимости делать что-то подобное:

включить $ (find_upwards top_level_rules.mk)

Вместо этого вы можете просто сделать

включить top_level_rules.mk

и он будет работать так же хорошо.)

Если файл не найден, find_upwards прервет сборку с сообщением об ошибке.

Если вы укажете более одного файла, find_upwards будет искать первый, затем
второй и так далее. Другими словами,

$ (find_upwards файл1 файл2)

эквивалентна

$ (find_upwards файл1) $ (find_upwards файл2)

Если вы хотите найти какой-либо из файлов, используйте вместо него find_first_upwards.

find_first_upwards file1 file2 ...
Эта функция ведет себя так же, как find_upwards, за исключением того, что возвращает первый файл любого
файлы в списке, который он находит. В частности, он проверяет текущий каталог на наличие
любой из файлов в списке и возвращает первый файл, который существует или может быть создан.
Если ни один из файлов не существует или не может быть построен в этом каталоге, он проверяет .., то
../ ..и т. д., пока он не достигнет корневого каталога или каталога, который
находится в другой файловой системе.

первый_доступный file1 file2 ...
Вернуть первый файл в списке, который существует или может быть создан. Это может быть полезно для
адаптация ваших make-файлов для работы на нескольких разных машинах или сетях, где
важные файлы могут находиться в разных местах. Например, вот строка из
один из моих make-файлов:

TCL_LIB = $ (first_available \
/usr/local/stow/tcl-8.4.5-nothread/lib/libtcl8.4.so \
/usr/lib/libtcl8.4.so /usr/lib/libtcl.so \
/net/na1/tcl8.4a3/lib/libtcl8.4.a \
/net/na1/tcl8.4a3/lib/libtcl8.4.sl)

Эта строка будет проверять наличие библиотеки Tcl во всех вышеперечисленных местах, останавливаясь на
первый, который он находит. Затем команда ссылки включает $ (TCL_LIB), поэтому мы получаем
соответствующая библиотека Tcl.

infer_linker file1 file2 ...
Учитывая список объектных файлов, сначала создайте их, если они еще не были. Тогда найди
зависят ли они от источника Fortran, C ++ или C и возвращают соответствующий
компилятор (который лучше умеет связывать, чем "ld").

infer_objects file1 file2 ..., описания
$ (infer_objects object1.o object2.o, * .o)

Если вы используете стандартные соглашения относительно имен файлов заголовков, makepp может
угадать, какие файлы ".o" или ".lo" нужно связать с вашей программой. Я использую это, чтобы
выбрать файлы из каталога библиотеки, который содержит модули, используемые во многих различных
программы. Вместо того, чтобы создавать библиотечный файл с расширением ".a" и позволять компоновщику выбирать
соответствующие модули, makepp может выбрать для вас соответствующие модули. Только так
соответствующие модули компилируются.

Алгоритм Makepp для вывода зависимостей объектов зависит от соглашения, которое
реализация всех классов или функций, определенных в файле заголовка "xyz.h",
скомпилирован в объектный файл с именем «xyz.o» (или «xyz.lo»). Итак, алгоритм makepp для
вывод зависимостей объектов начинается с одного или нескольких объектов, которые, как мы знаем, должны быть
связаны с программой. Он проверяет, какие файлы были включены с помощью "#include" в
эти источники и пытается найти соответствующие объектные файлы для каждого из включаемых
файлы.

«$ (infer_objects)» необходимо указать в списке зависимостей программы, например
это:

myprog: $ (infer_objects main.o another_object.o, \
** / *. o /other/library/dirs/**/*.o)
$ (CXX) $ (входы) -o $ (выход) $ (LIBS)

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

Например, предположим, что «main.o» происходит от «main.cpp», который включает «my_class.h».
«$ (infer_objects)» ищет файлы с именем «my_class.o». Если ровно один такой
файл найден, он добавлен в список. (Если обнаружены два объектных файла my_class.o
в разных каталогах печатается предупреждающее сообщение.) "infer_objects" также
проверяет my_class.cpp, чтобы увидеть, что он включает, и какие дополнительные объектные файлы
подразумеваемых.

мктемп
мктемп префикс
мктемп префиксXXX
темп /
Возвращает непредсказуемое временное имя файла, которого в настоящее время не существует. Без имени
указание на один и тот же файл возвращается дважды, даже с разными относительными путями,
за один запуск makepp (кроме, возможно, традиционной рекурсивной программы make или если Perl
код, выполняемый внутри действия правила, вызывает "f_mktemp"). В конце makepp запустите все
файлы, возвращаемые этой функцией, удаляются, если они существуют (опять же, за исключением
возвращается этой функцией в коде Perl, работающем в правиле).

Любое количество букв "X" в верхнем регистре в конце аргумента заменяется таким количеством
случайные буквы и цифры. Чем их больше, тем меньше вероятность столкновения
с другими процессами, поэтому, если вы зададите префикс типа "/ tmp / abc.", тебе должно хватить
«Х» с. Если X больше одного, первый символ берется из идентификатора процесса. Если
их нет, как будто их десять, что якобы достаточно (8.4e17
возможности или 3.7e15 в Windows). Если аргумента нет, используется префикс по умолчанию
"температура"в текущем каталоге.

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

Кроме того, поскольку он всегда отличается, вы должны использовать его в действии правила, только если вы используете
": build_check ignore_action":

TMPFILE; = вызов $ (mktemp) # 1; "=" будет означать 3 вызова: 3 файла
A-счет B-счет:: build_check ignore_action
произвести-как-и-B> $ (TMPFILE)
& grep -c / A / $ (TMPFILE) -o A-счет
& grep -c / B / $ (TMPFILE) -o счетчик B

Или вы должны экспортировать его и позволить оболочке оценить его:

экспорт TMPFILE; = $ (mktemp)
A-счет B-счет:
произвести-как-и-Bs> $$ TMPFILE # makepp не видит значение var
fgrep -c A $$ TMPFILE> A-счетчик
fgrep -c B $$ TMPFILE> B-счетчик

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

% .x:% .y
& grep foo $ (ввод) -o $ (mktemp)
& sed bar $ (mktemp /) -o $ (output) # Оперировать с выводом & grep

Notdir имена файлов
Возвращает часть имени файла (имен), не относящуюся к каталогу, то есть все, что находится после последнего
косая черта, если он есть, или все имя файла в противном случае.

only_generated имена файлов
Возвращает только те имена файлов в списке, которые были сгенерированы makepp, а не с тех пор.
изменен в соответствии с файлом информации о сборке.

Эта функция полезна в чистых целевых правилах (хотя, конечно, makeppclean - это
предпочтительный вариант):

$ (фиктивная чистота):
& rm -f $ (только_генерированный ** / *)

only_nontargets имена файлов
Возвращает только те имена файлов в списке, которые не являются целями какого-либо правила (либо
явные или шаблонные правила). Вы можете указать подстановочный знак (см. «$ (Подстановочный знак)»
для получения более подробной информации о подстановочных знаках makepp). Это можно использовать для создания
цель распространения, например:

.PHONY: распространение

распределение:
& mkdir our_product - $ (ВЕРСИЯ)
& cp $ (фильтрация% ~, $ (only_nontargets *)) наш_продукт - $ (ВЕРСИЯ)
tar cf - наш_продукт - $ (ВЕРСИЯ) | gzip -9c> наш_продукт - $ (ВЕРСИЯ) .tar.gz

В этом случае "$ (only_nontargets *)" возвращает каждый файл в текущем каталоге.
это не цель какого-то правила. "$ (Filter_out% ~, ...)" удаляет редактор
резервные копии.

Подобно only_targets (см. Выше), only_nontargets знает только те цели, которые
уже определены. Это проблема, только если вы используете его для определения переменных.
с присвоением ": ="; если вы используете его в списке зависимостей или в теле
правило, все остальные правила уже были просмотрены.

only_stale имена файлов
Возвращает только те имена файлов в списке, которые были сгенерированы makepp, а не с тех пор.
изменены в соответствии с файлом информации о сборке, но больше не являются целями какого-либо правила.

Эта функция полезна для проверки отсутствия зависимостей от таких файлов,
без принудительной чистой сборки всех целей:

$ (фальшивый флеш):
& rm -f $ (только_стейл ** / *)

На самом деле, вероятно, лучше вместо этого написать сценарий, который вызывает makepp для генерации
список устаревших файлов, а затем попросите этот сценарий удалить все перечисленные файлы, которые
в настоящее время не находятся под контролем версий, на всякий случай, если сгенерированный файл станет источником
файл. Makepp не имеет встроенной такой функции, потому что makepp (и, вероятно,
должен оставаться) агностиком в отношении управления версиями.

only_targets имена файлов
Возвращает только те имена файлов в списке, которые на самом деле являются целями какого-либо правила.
(явные или шаблонные правила). Вы можете указать подстановочные знаки (включая makepp
специальный подстановочный знак "**") в именах файлов. (Подробнее см. Функцию "$ (подстановочный знак)"
Детали. Это можно использовать для чистой цели, например:

.PHONY: чистый

чистить:
& rm -f $ (только_назначения *)

Теперь, если вы наберете «makepp clean», он удалит все, что умеет создавать. Но
не создавайте чистую цель, вместо этого используйте makeppclean!

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

mylib.a: * .o
& rm -f $ (вывод)
$ (AR) cr $ (выход) $ (входы)

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

mylib.a: $ (only_targets * .o)
& rm -f $ (вывод)
$ (AR) cr $ (выход) $ (входы)

тогда этой проблемы не будет.

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

ALL_TARGETS: = $ (only_targets *)

цель1: зависимость1
действия

цель2: зависимость2
действия

тогда only_targets не будет знать о последующих правилах.

Точно так же only_targets не знает о целях, созданных в make-файлах, которые
загружен рекурсивным make. (Но вы все равно не должны использовать рекурсивный make; используйте
используйте вместо этого оператор load_makefile или неявную загрузку файла makefile.)

относительное_имя_файла file1 file2 file3 [, косая черта]
Возвращает имя этих файлов относительно текущего каталога (
makefile находится внутри). Это также можно использовать для удаления ненужных "./" и прочего мусора из
путь:

DIR: =.
ПОДРАЗДЕЛЕНИЕ: = ..
FNAME: = $ (DIR) /../ otherdir / $ (SUBDIR) / files
X: = $ (относительное_имя_файла $ (FNAME))

If слэш верно (обычно 1) возвращаемые имена файлов гарантированно содержат косую черту
добавив при необходимости "./", чтобы вы могли использовать его в качестве имени исполняемого файла без
беспокоясь о том, что путь поиска команды переопределяет местоположение каталога.

Если путь идет по корневому каталогу, родительский элемент либо вашего домашнего каталога, либо
"$ (ROOT)" вашей системы сборки или в Windows корень диска (в зависимости от
окружающей среды, это также происходит для / cygdrive / c or /c), абсолютный путь будет
вместо этого вернулся.

относительно file1 file2 file3 [, каталог]
Возвращает имя этих файлов относительно указанного каталога. Это
обычно полезно, когда по какой-либо причине вам нужно выполнить команду из
другой каталог (текущий каталог по умолчанию):

исходный_бэкап.tar:
cd .. && tar cf $ (относительный_к $ (вывод), ..) $ (относительный_к., ..)

суффикс имена ...
Извлекает суффикс каждого имени файла в имена. Если имя файла содержит точку,
суффикс - все, что начинается с последней точки. В противном случае суффиксом будет
пустой строки. Это часто означает, что результат будет пустым, когда имя не указано,
и если имена содержат несколько имен файлов, результат может содержать меньше имен файлов.

Например,

$ (суффикс src / foo.c src-1.0 / bar.c хаки)

выдает результат ".c .c".

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

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

Makepp поддерживает все обычные символы подстановки оболочки («*», «?» И «[]»). Он также имеет
подстановочный знак «**», который соответствует любому количеству промежуточных каталогов. (Эта идея была
украдено из zsh.) Например, "** / *. c" соответствует всем .c файлы во всем источнике
дерево. "objects / ** / *. o" соответствует всем .o файлы, содержащиеся в любом месте
подкаталог объекты или любой из его подкаталогов или любой из их подкаталогов. В
Подстановочный знак "**" не будет следовать за программными ссылками на каталоги любого уровня и не будет
попытаться войти в каталоги, которые существуют, но не могут быть прочитаны. Также файлы и
каталоги, которые существуют, но не могут быть прочитаны, не будут возвращены символом «$ (подстановочный знак)».

строка функции
добавить префикс приставка, слова
Добавляет строку префикса к каждому слову. Это в основном для GNU make
совместимость; используя расширение в стиле rc, это можно сделать более читаемым способом
как это:

МОДУЛИ: = abcd
X_OLD_STYLE: = $ (добавить префикс $ (OBJDIR) /, $ (добавить суффикс .o, $ (МОДУЛИ)))
X_NEW_STYLE: = $ (OBJDIR) / $ (MODULES) .o # Разве так не легче читать?

добавляет суффикс суффикс, слова
Добавляет строку суффикса к каждому слову. Это в основном для GNU make
совместимость; используя расширение в стиле rc, это можно сделать более читаемым способом
как это:

X_OLD_STYLE: = $ (добавляет суффикс .o, $ (МОДУЛИ))
X_NEW_STYLE: = $ (МОДУЛИ) .o

призывают Переменная[, слова] ...
Функция «вызов» уникальна тем, что ее можно использовать для рассмотрения переменная как
параметризованная функция. Вы можете присвоить сложное выражение переменная И использовать
"вызов", чтобы расширить его содержимое до различных значений, параметризованных слова позже. В
другие системы make, переменная, которая используется в основном для расширения с помощью
"звонок", называется макрос.

Во время раскрытия макроса временные переменные $1, $2, "..." обратитесь к
аргументы, данные "call" во время его вызова. Переменная $0 будет расширен до
имя макроса (т.е. переменная) этот «звонок» в настоящее время расширяется.

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

Сначала простой пример:

rest = $ (список слов 2, $ (слова $ (1)), $ (1))
list = ABCDE
butfirst: = $ (перезвонить, $ (список))

Здесь переменная «$ (butfirst)» будет содержать список «BCDE».

А теперь более сложный пример, показывающий, что возможно:

rest = $ (список слов 2, $ (слова $ (1)), $ {1})
mymap = $ (if $ 2, $ (call $ 1, $ (firstword $ 2)) $ (call $ 0, $ 1, $ (call rest, $ 2)))
downcase = $ {makeperl lc ("$ 1")}

UCWORDS = ВСЕ ЭТИ СЛОВА ИСПОЛЬЗУЮТСЯ
DCWORDS: = $ (вызвать mymap, downcase, $ (UCWORDS))

Теперь «$ (DCWORDS)» содержит «все эти слова в верхнем регистре». Кстати: не делает
разница, получаем ли мы доступ к аргументам через $1, "$ {1}" or "$ (1)" внутри макроса.

Вы можете напрямую использовать переменную, как если бы это была функция, если нет
функция этого имени. Это внутренне преобразовано в "вызов", поэтому они
эквивалент:

обсуждение = $ 0 превратился в $ 1 $ 2.
direct = $ (обсуждение, аргумент)
называется = $ (обсуждение вызова, аргумент)

Может показаться спорным, должен ли «$ [call]» также расширять макрос «$ []»
выражения, или должна ли функция всегда делать одно и то же, независимо от того, как
называется. Последний был выбран, потому что при обычном синтаксисе make это было бы
невозможно получить "$ [1], $ [2] ..." в переменную (они ничего не заменят,
еще до того, как произойдет присвоение.) Следовательно, если у вас есть макрос для определения
правило, вы хотите, чтобы выражения типа "$ (output)" были видны при синтаксическом анализе правила, поэтому
вы должны защитить их от «звонка»:

определить мир
2 1: XNUMX долларов
mycommand $$ (ввод) -o $$ (вывод)
Endef
$ [myrule myinput, myoutput]

фильтр узоры, слова
Возвращает все слова в списке, соответствующие шаблонам. Шаблоны могут быть просто другими
слова или подстановочные знаки имени файла (т. е. распознаются «*», «?» и «[az]»), или они могут
имеют символ «%», что означает соответствие любой строке в этой точке (то же самое, что и «*»).

отфильтровано узоры, слова
Возвращает все слова в списке, которые не соответствуют шаблонам. Шаблоны могут быть просто
другими словами, или подстановочные знаки имени файла (т. е. распознаются «*», «?» и «[az]»), или
они могут иметь символ "%", что означает соответствие любой строке в этой точке (так же, как
«*»).

Например:

libproduction.a: $ (filter_out test_ *, $ (подстановочный знак * .o))

поставлю все .o файлы, которые существуют или могут быть созданы, за исключением тех, которые начинаются с тестXNUMX_,
в libproduction.a.

находка найти, in
ВОЗВРАТ найдите, если это подстрока in.

первое слово слова
Верните первое слово.

карта слова, Perlcode
составить карту слова, Perlcode
Аналогично карте Perl применяется Perlcode к каждому слову по очереди и возвращает
полученные результаты. Первый вариант - это простой код Perl, а второй вариант сначала проходит
perlcode через расширение переменных в стиле Make. Слова расширены в обоих
случаи.

Слова находятся в $ _ и возвращаются, если вы не undef $ _. Это предназначено для
доработки с трудом поддаются "пацубст". Только первая запятая является разделителем,
любые другие считаются частью Perlcode.

# Переключить слова. Двойные скобки, чтобы разрешить парные скобки в perlcode, или используйте $ {}:
X = $ ((map $ (VALUES), s /(.+)-(.+)/$ 2- $ 1 /))
# Вы можете использовать выражения make, но тогда вы должны использовать $$ для Perl $:
Y = $ (makemap $ (VALUES), tr / $ (OLDCHARS) / $ (NEWCHARS) / или $$ _ = 'не удалось')
# Вы можете исключить кандидатов:
Y = $ (map $ (ЗНАЧЕНИЯ), undef $ _ if / no_good /)

присоединиться слова1, слова2
Сделайте попарное соединение первых слов и вторых слов.

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

OBJS = $ (patsubst% .c, каталог_объекта /%. O, $ (C_SOURCES))

берет каждый файл в C_SOURCES и возвращает имя объектного файла в object_dir.
Иногда более кратко использовать ссылку на замену, например, приведенное выше может
были написаны как

OBJS = $ (C_SOURCES:%. C = каталог_объектов /%. O)

sort word1 word2 word3 ...
Сортирует слова в лексическом порядке и удаляет дубликаты.

полоса string
Удаляет начальные и конечные пробелы из строки и заменяет каждый внутренний
последовательность из одного или нескольких пробелов с одним пробелом. Таким образом, "$ (strip ab
c) "приводит к" abc ".

SUBST от, до, текст
Выполняет текстовую замену текстового текста: заменяется каждое вхождение from
по к. Результат заменяется вызовом функции. Например,

$ (subst ee, EE, ноги на улице)

подставляет строку «плата за СТРЕЛКУ».

слово n, текст
Возвращает nое слово текст. Законные ценности n начать с 1 в начале
или назад от -1 в конце. Если n больше, чем количество слов в текст,
значение пусто.

список слов индексный список, слова
список слов первый индекс, последний индекс, слова
В первой форме вы указываете список индексов (начиная с 1 в начале или
назад от -1 в конце), чтобы выбрать нужные слова. Во второй форме вы
укажите диапазон слов, которые вы хотите вернуть.

слова текст
Возвращает количество слов в текст.

Прочее функции
Еогеасп var, list, text
Первые два аргумента, вар и список, раскрываются до того, как что-либо будет сделано; Примечание
что последний аргумент, текст, не раскрывается при этом. Затем для каждого слова
расширенное значение списка, переменная, названная расширенным значением var, устанавливается в
это слово, и текст расширяется. Предположительно текст содержит ссылки на эту переменную,
поэтому его расширение будет каждый раз разным.

Этот простой пример устанавливает переменную файлов к списку всех файлов в
каталоги в списке каталоги:

dirs: = abcd
файлы: = $ (foreach каталог, $ (каталоги), $ (подстановочный знак $ (каталог) / *))

Здесь текст - «$ (подстановочный знак $ (dir) / *)». Первое повторение находит значение "a" для dir,
поэтому он дает тот же результат, что и «$ (подстановочный знак a / *)»; второе повторение производит
результат «$ (подстановочный знак b / *)»; и третий - "$ (подстановочный знак c / *)".

Этот пример имеет тот же результат (за исключением установки dirs), что и следующий пример:

файлы: = $ (подстановочный знак a / * b / * c / * d / *)

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

find_files = $ (подстановочный знак $ (каталог) / *)
dirs: = abcd
файлы: = $ (foreach dir, $ (dirs), $ (find_files))

Здесь мы используем переменную find_files таким образом. Мы используем простой знак "=" для определения
рекурсивно расширяющаяся переменная, так что ее значение содержит фактический вызов функции для
быть повторно расширенным под управлением foreach; просто расширяемая переменная не подходит,
поскольку подстановочный знак будет вызываться только один раз во время определения find_files.

Примечание: не путайте это со специальной переменной «$ (foreach)».

info текст
предупреждение текст
ошибка текст
Выходной текст, возвращающий ничего. Первый идет в STDOUT, второй - в STDERR,
третий дополнительно прерывает обработку.

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

file_list:
# команды оболочки для вычисления списка файлов для помещения в программу

моя_программа: $ (& cat $ (предварительно созданный список_файлов))

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

file_list; = $ (& cat $ (предварительно созданный список_файлов))

my_program1: ao $ (список_файлов)

my_program2: bo $ (список_файлов)

Если вместо этого вы укажете просто «$ (& cat file_list)», то makepp не будет принудительно
file_list должен быть актуальным перед выполнением команды оболочки. Использование "$ (предварительная сборка)"
лучший способ решить эту проблему. У вас может возникнуть соблазн попробовать что-то другое, например
это:

моя_программа: список_файлов $ (& cat список_файлов)

но это не сработает, потому что "$ (& cat file_list)" вычисляется до того, как makepp попытается
построить "список_файлов".

only_phony_targets имена
Возвращает только те имена в списке, которые являются фальшивыми целями некоторого правила (либо
явные или шаблонные правила). Вы можете указать подстановочные знаки (включая специальные
подстановочный знак, "**") в именах файлов. (Подробнее см. Функцию «$ (подстановочный знак)».
Это можно использовать для группировки целей, например:

$ (фальшивые тесты): $ (only_phony_targets * / ** / tests)

происхождения переменная
Зная имя переменной, сообщает вам, откуда взялось ее значение.

Perl Perlcode
мейкперл Perlcode
Оценивает perlcode в блоке и возвращает результат. Первый вариант - это простой Perl
code, а второй вариант сначала передает код perlcode через переменную Make-style
расширение.

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

ВАР = 1
VAR1 = $ {perl ($ VAR + 1) * 3}
VAR2 = $ (perl do {$ VAR * = 3; вернуть $ VAR + 1}, если $ VAR)
VAR3 = $ (makeperl $ (VAR1) * 3 + $$ VAR) # одна переменная Make и одна переменная Perl
VAR = $ ((perl, если (...) {...}))

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

$ (фальшивый все): my_program

$ (фиктивная чистота):
& rm -f * .o моя_программа

Вы также можете объявить одну или несколько целей фальшивыми с помощью такой строки в любом месте
ваш make-файл:

.PHONY: все чисто

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

XYZ: = $ (распечатать $ (patsubst% .c,% o, $ (SOURCE_FILES)))

распечатает результат вызова "пацубст".

XYZ: = $ (patsubst% .c,% o, $ (print $ (SOURCE_FILES)))

распечатает последний аргумент вызова "patsubst".

оболочка оболочка-команда
Возвращает вывод заданной команды оболочки с заменой новой строки пробелами.

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

date = $ (дата оболочки) # лучше: $ (perl скалярное локальное время)
VAR = $ {{shell f () {эхо привет; }; f}}

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

Это делается для того, чтобы избежать превышения лимита длины команды в вашей системе.
Например, если есть много сгенерированных файлов, вы, вероятно, захотите, чтобы ваш
чистую цель (которой у вас не должно быть, потому что "makeppclean" более эффективен), чтобы
выглядят примерно так:

$ (фиктивная чистота):
$ (xargs $ (RM), $ (only_targets ** / *))

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

$ (фиктивная чистота):
& rm -f $ (только_цели ** / *)

Если указан третий аргумент, он используется для постфикса каждой команды. Это
полезно для указания перенаправителей, например (хотя здесь снова поможет & echo):

манифест:
& rm -f $ @
& коснуться $ @
$ (xargs echo, $ (only_nontargets ** / *), >> $ @)

Часть этой документации основана на документации GNU make.

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

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