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

ПРОГРАММА:

ИМЯ

makepp_exnding - Как расширить makepp с помощью Perl

ОПИСАНИЕ

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

Общие ноты on письмо Perl код в работает макияж
Каждый make-файл находится в своем собственном пакете. Таким образом, определения в одном make-файле не влияют на
определения в другом make-файле. Единый набор функций, включающий все стандартные
Функции обработки текста импортируются в пакет при его создании.

Переменные Makefile хранятся в этом пакете как скаляры Perl. (Есть исключения из
это: автоматические переменные и значение по умолчанию таких переменных, как CC, на самом деле
реализованы как функции без аргументов. Целевые переменные, переменные командной строки и
переменные среды не видны таким образом.) Таким образом, любой код Perl, который вы пишете, имеет доступ ко всем
переменные makefile. Глобальные переменные хранятся в пакете «Mpp :: global». Видеть
Переменные Makefile для подробностей.

Каждый из операторов (ifperl / ifmakeperl, perl / makeperl, sub / makeub),
функции (perl / makeperl, map / makemap) и действие правила (perl / makeperl) для
Написание кода Perl непосредственно в make-файле бывает двух видов. Первый абсолютно
нормальный Perl, то есть вы должны использовать префикс "f_", как объяснено в следующем разделе, если
вы хотите вызывать функции makepp. Второй вариант сначала пропускает оператор через
Расширение переменных в стиле make, что означает, что вам нужно удвоить символы "$", которые вы хотите, чтобы Perl видел.

Конечная обработка особенная, потому что огромные (в зависимости от вашей системы сборки) данные makepp
сборка мусора при нормальном выходе займет несколько секунд. Итак, мы делаем
выход грубой силой. В основном процессе у вас все еще могут быть блоки «КОНЕЦ», но если они у вас есть
глобальные дескрипторы файлов они не могут быть сброшены. Но вы должны использовать современную лексическую
дескрипторы файлов, которые закрываются должным образом при выходе из области видимости.

В коде Perl, запускаемом непосредственно как действие правила или через определенную вами команду, это
противоположный. Блоки "END" не будут запускаться, но глобальные дескрипторы файлов будут сброшены за вас. В
«УНИЧТОЖЕНИЕ» глобальных объектов никогда не будет запущено.

Добавление new текстовый Функции
Вы можете добавить новую функцию в репертуар makepp, просто определив подпрограмму Perl
то же имя, но с префиксом "f_". Например:

суб f_myfunc {
мой $ аргумент = & arg; # Назовите аргумент.
мой (undef, $ mkfile, $ mkfile_line) = @_; # Назовите аргументы.

... сделай что-нибудь здесь

return $ return_value;
}

XYZ: = $ (myfunc мои аргументы функции)

Если ваша функция не принимает аргументов, делать нечего. Если ваша функция занимает один
аргумент, как в примере выше, используйте простой метод доступа & arg для его получения. если ты
ожидая большего количества аргументов, вам понадобится более сложный метод доступа «args», описанный ниже.

Эти средства доступа обрабатывают те же три параметра, которые должны быть переданы любому "f_"
функции, а именно аргументы функции, объект make-файла и дескриптор строки для
Сообщения. Поэтому в первом случае вы можете использовать эффективную форму & arg.

Аксессор & arg позаботится о следующем: если аргументы уже были
расширен (например, чтобы найти имя функции в "$ (my $ (function) arg)", аргумент будет
передается как строка и просто возвращается. Если аргумент все еще нуждается в расширении, это
в обычном случае это ссылка на строку. Аксессор & arg расширяет его для вас,
для которого ему нужен объект makefile в качестве второго параметра.

Если вы ожидаете большего количества аргументов, возможно, в количестве переменных, задание выполняется с помощью «args».
Этот метод доступа принимает те же 3 параметра, что и arg, плюс дополнительные параметры:

max: количество аргументов (по умолчанию 2): дать ~ 0 (maxint) для бесконечности
min: количество аргументов (по умолчанию 0, если max ~ 0, в остальном то же, что и max)
only_comma: не используйте пробелы вокруг запятых, обычно для не имени файла

Максимум max, но минимум min запятые, присутствующие перед раскрытием, используются для разделения
аргументы. Некоторые примеры из встроенных функций makepp:

мой ($ префикс, $ текст) = аргументы $ _ [0], $ _ [1], $ _ [2], 2, 2, 1; # addprefix
для моего $ cond (args $ _ [0], undef, $ _ [2], ~ 0) ... # и, или
мой @ args = args $ _ [0], $ _ [1], $ _ [2], ~ 0, 1, 1; # вызов
мои ($ фильтры, $ слова) = аргументы $ _ [0], $ _ [1], $ _ [2]; # фильтр

Функция должна возвращать скалярную строку (не массив), которая затем вставляется в
текст в этот момент.

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

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

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

Обратите внимание, что среда (в частности, cwd), в которой вычисляется функция, будет
не обязательно соответствовать среде, в которой правила из Makefile, в котором
функция была оценена, выполнены. Если для вас это проблема, то ваша функция
вероятно, должно выглядеть примерно так:

суб f_foo {
...
chdir $ makefile -> {CWD};

... И т.д.
}

Полагая Функции в a Perl модуль
Если вы поместите функции во включаемый файл, у вас будет одна копия для каждого Makeppfile, который
использует это. Чтобы этого избежать, вы можете написать их как обычный модуль Perl с помощью «Экспортера».
интерфейс и используйте его. Это ускорит загрузку и сэкономит память:

perl {используйте mymodule}
перл {
использовать my :: module; # положить: на новую строку, чтобы она, как правило, не анализировалась
}

Если вам нужна какая-либо из функций, обычно доступных в Makefile (например, "f_"
functions, "arg" или "args"), вы должны поместить эту строку в свой модуль:

используйте Mpp :: Subs;

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

призвание и, что лучший способ Perl скрипты
Если вы вызываете внешний Perl-скрипт через "system" или как правило, makepp создаст форк
новый процесс (если это не последнее действие правила) и запустить новый интерпретатор Perl.
В этом нет ничего плохого, кроме того, что есть более эффективный способ:

&команду аргументы ...
Это может быть действие правила. Он вызовет функцию команду с префиксом "c_" и
передать ему оставшиеся (необязательно цитируемый стиль makepp - не совсем то же самое, что и
Shell) аргументы. Если такую ​​функцию найти не удается, все строки передаются в
"запустить".

sub c_mycmd {мой @args = @_; ...}

$ (фальшивый callcmd):
& mycmd 'arg с пробелом' arg2 "arg3" # вызывает c_mycmd

%.наружу внутрь
& myscript -o $ (output) $ (input) # вызывает внешний myscript

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

За блочным оператором «Mpp :: Cmds :: frame» следует однобуквенный список опций:
встроенные функции (максимально "qw (fi I ​​o O rs)"). Даже если вы укажете свой вариант
отменяя одно из них, вы все равно даете единственную букву стандартного варианта.

Каждая собственная опция указывается как "[qw (n имя), \ $ ref, аргумент, sub] ", Первые два
элементы - это короткое и длинное имя, за которым следует ссылка на переменную и, необязательно,
логическое значение, указывающее, следует ли принимать аргумент. Без аргумента переменная
увеличивается каждый раз, когда предоставляется опция, иначе в ней сохраняется значение опции.

sub c_my_ocmd {# Типичный вариант вывода
местный @ARGV = @_;
Mpp :: Cmds :: frame {

... напечатайте что-нибудь здесь с @ARGV, с уже автоматически удаленными параметрами

} 'f', qw (o O);
}

sub c_my_icmd {# Типичный вариант ввода с 2 вариантами
местный @ARGV = @_;
мои ($ короткие, $ длинные);
Mpp :: Cmds :: frame {

... сделайте что-нибудь здесь с помощью <>

} qw (i I rs), # s указывает только --separator, а не -s
[qw (s short), \ $ short], # Без опции arg -> $ short == 1
[qw (l long), \ $ long, 1, sub {warn "got arg $ long"}];
}

Вот простая команда, которая преобразует только первый символ каждого ввода
запись (эквивалентно "& sed '$$ _ =" \ u \ L $$ _ "'"):

суб c_uc {
местный @ARGV = @_;
Mpp :: Cmds :: frame {
напечатайте "\ u \ L $ _" while <>;
} 'f', qw (i I или O rs);
}

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

Mpp :: Cmds :: perform {...} 'сообщение';

Будет выведено сообщение с «--verbose» (которое принимает каждая команда), если
команда успешно запущена. Но если блок считается ложным, он умирает с
отрицательное сообщение.

пробег скрипт аргументы ...
Это обычная функция Perl, которую вы можете использовать в любом контексте Perl в вашем make-файле.
Он похож на систему с несколькими аргументами, но запускает сценарий Perl в
текущий процесс. Для операторов makepp функция perl или ваши собственные функции
это процесс, выполняющий makepp. Но для правила, которое выполняет подпроцесс
Это. Скрипт анализируется столько раз, сколько он вызывается, но вы можете поставить настоящую
работать в библиотеке, как это делает pod2html. Затем эту библиотеку можно использовать на верхнем уровне, поэтому
что он уже присутствует:

perl {use mylib} # разветвляется на все правила, которые не нуждаются в повторном анализе

%.наружу внутрь
makeperl {запустить qw'myscript -o $ (output) $ (input) '}

Если сценарий вызывает «exit», закрывает стандартные файловые дескрипторы или полагается на систему
чтобы очистить после него (открытые файлы, память ...), это может быть проблема с "запуском". Если
вы вызываете "run" внутри операторов или функцию perl, makepp может нарушиться или
очистка происходит только в конце makepp.

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

Writing надежная собственный подпись методы
Иногда вам нужно, чтобы makepp вычислял метод подписи с использованием другой техники. Для
Например, предположим, что у вас есть двоичный файл, который зависит от разделяемой библиотеки. Обычно, если вы
изменить общую библиотеку, вам не нужно повторно связывать исполняемые файлы, которые зависят от нее, потому что
связывание выполняется во время выполнения. (Однако возможно, что повторное связывание исполняемого файла
может быть необходимо, поэтому я не сделал это по умолчанию.) Что вы хотите makepp
нужно иметь такую ​​же подпись для общей библиотеки, даже если она изменится.

Этого можно добиться несколькими способами. Самый простой способ - создать свой новый
метод подписи (назовем его «shared_object»). Вы бы использовали этот метод подписи
только для правил, связывающих двоичные файлы, например:

моя программа: * .o lib1 / lib1.so lib2 / lib2.so
: подпись shared_object
$ (CC) $ (входы) -o $ (выход)

Теперь нам нужно создать метод подписи.

Все методы подписи должны быть их собственным классом, и этот класс должен содержать несколько специальных
items (подробности см. в Mpp / Signature.pm в дистрибутиве). Имя класса должно быть
с префиксом «Mpp :: Signature ::», поэтому в этом случае наш класс должен вызываться
«Mpp :: Подпись :: общий_объект». Нам нужно создать файл с именем общий_объект.pm и положить
это в Mpp :: Подпись каталог где-нибудь в пути включения Perl; самое легкое место
может быть в Mpp / Подпись каталог в установке makepp (например,
/ usr / local / share / makepp / Mpp / подпись или где бы вы его не установили).

Чтобы получить более подробную информацию о том, что должно пройти в этом классе, вам следует внимательно просмотреть
файла Mpp / Signature.pm и, вероятно, также Mpp / Подпись / exact_match.pm в makepp
распределение. Но в нашем случае все, что мы хотим сделать, это внести очень небольшое изменение в
существующий механизм подписи; если файл является разделяемой библиотекой, мы хотим иметь константу
подпись, тогда как если это что-то еще, мы хотим полагаться на нормальный makepp
механизм подписи. Лучший способ сделать это - унаследовать от
"Mpp :: Signature :: c_compilation_md5", который является обычно выбираемым методом подписи.
когда makepp распознает команду ссылки.

Итак, файл Mpp / Подпись / shared_object.pm может содержать следующее:

использовать строго;
пакет Mpp :: Signature :: shared_object;
используйте Mpp :: Signature :: c_compilation_md5;
наш @ISA = qw (Mpp :: Signature :: c_compilation_md5); # Укажите наследование.
наш $ shared_object = bless \ @ISA; # Волшебство, помогающее makepp найти
# подпрограммы для этого метода. Все
# методы подписи должны иметь один из них.
# Значение не используется, просто любой объект.
# Теперь вот метод, который вызывается, когда нам нужна подпись
# любая цель или зависимость, для которых активен этот метод подписи:
дополнительная подпись {
my ($ self, # Это будет то же самое, что и $ shared_object.
$ finfo) = @_; # Специальная структура, которая содержит все
# makepp знает об этом файле. Видеть
# Mpp / File.pm для подробностей.

if ($ finfo -> {NAME} = ~ /\.s[oapting$/) {# Заканчивается ли имя файла на .so или .sa?
вернуть $ finfo-> file_exists? 'существуют' : '';
# Всегда возвращать ту же подпись, если файл
# существуют. В этом случае подпись - это
# строка "существует".
}

Mpp :: Signature :: c_compilation_md5 :: signature;
# Если файл не заканчивался на .so или .sa,
# делегировать обычный метод подписи makepp.
}

Этот файл предоставляется в качестве примера в дистрибутиве makepp с некоторыми дополнительными
комментариев.

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

Предположим, например, что общая библиотека вызывает некоторые подпрограммы, которые ваша программа
обеспечивает. Например, предположим, что вы изменили общую библиотеку так, чтобы теперь она вызывала внешнюю
подпрограмма "xyz ()". Если вы не используете для компоновщика параметр «-E» или «--export-dynamic»
(для GNU binutils; другие компоновщики имеют другие имена параметров), символ "xyz ()" не может
быть доступным компоновщику времени выполнения, даже если он существует в вашей программе.

Еще хуже, предположим, что вы определили «xyz ()» в другой библиотеке (назовите ее libxyz), как это:

моя_программа: main.o lib1 / lib1.so xyz / libxyz.a

Поскольку "libxyz" - это .a файл, а не .так файл, то "xyz ()" не может быть загружен
правильно от libxyz.a если вы не повторно свяжете свой двоичный файл.

Методы Mpp :: Signature также управляют не только строкой, которая используется для определения наличия
файл изменился, но алгоритм, который используется для сравнения строк. Например,
метод подписи "target_newer" в дистрибутиве makepp просто требует, чтобы
цели новее, чем зависимости, тогда как метод сигнатуры "exact_match" (и
все, что от него зависит, например «md5» и «c_compilation_md5») требует, чтобы
файл имеет ту же подпись, что и в последней сборке.

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

· Метод подписи для разделяемых библиотек, который возвращает контрольную сумму всех экспортированных
символы, а также все необходимые символы из других библиотек. Это решает
проблема с приведенным выше примером и гарантирует правильную ссылку при любых обстоятельствах.
Была предпринята экспериментальная попытка сделать это в дистрибутиве makepp (см.
Mpp / Подпись / shared_object.pm), но он будет работать только с GNU binutils и ELF
библиотеки на данный момент.

· Метод подписи, который игнорирует отметку даты, записанную в файл. Например, если вы
генерировать .c файл автоматически с помощью некоторой программы, которая настаивает на помещении строки
в таком виде:

static char * date_stamp = "Создано автоматически 01 апреля 2004 никем";

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

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

· Метод подписи, который знает, как игнорировать комментарии в файлах latex, поскольку
Метод "c_compilation_md5" умеет игнорировать комментарии в файлах C.

· Метод подписи для автоматического извлечения документации, который проверяет только контрольные суммы
комментирует, что требуется экстрактору документации, и игнорирует другие изменения в источнике
.

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

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