makepp_extending - онлайн у хмарі

ПРОГРАМА:

ІМ'Я

makepp_extending -- Як розширити makepp за допомогою Perl

ОПИС

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

Загальне ноти on лист Perl код до робота з makepp
Кожен 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 має величезні (залежно від системи збірки) дані
Конструкціям знадобиться кілька секунд для збору сміття за допомогою нормального виходу. Тож ми робимо а
вихід грубої сили. В основному процесі ви все ще можете мати блоки "END", але якщо вони є
глобальні дескриптори файлів, вони можуть не бути очищені. Але ви повинні використовувати сучасну лексику
дескриптори файлів, які закриваються належним чином, коли виходять за межі області дії.

У коді Perl, який виконується безпосередньо як дію правила або за допомогою визначеної вами команди, це
навпаки. Блоки "END" не запускатимуться, але глобальні дескриптори файлів очищаються за вас. The
"DESTROY" глобальних об'єктів ніколи не буде запущено.

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

sub f_myfunc {
мій $аргумент = &arg; # Назвіть аргумент.
my(undef, $mkfile, $mkfile_line) = @_; # Назвіть аргументи.

... зробіть щось тут

повернути $return_value;
}

XYZ := $(myfunc мої аргументи func)

Якщо ваша функція не приймає аргументів, нічого робити. Якщо ваша функція займає один
аргумент, як у наведеному вище прикладі, скористайтеся простим методом доступу &arg для його отримання. Якщо ви
очікувати більше аргументів, вам потрібен більш складний метод доступу "args", описаний нижче.

Ці засоби доступу обробляють ті самі три параметри, які слід передати будь-якому "f_"
функцію, а саме аргументи функції, об’єкт makefile та дескриптор рядка для
повідомлення. Тому ви можете використовувати ефективну форму &arg у першому випадку.

Метод доступу &arg подбає про наступне за вас: Якщо аргументи вже були
розгорнуто (наприклад, щоб знайти ім'я функції в "$(my$(function) arg)" аргумент є
передається як рядок і щойно повертається. Якщо аргумент все ще потребує розширення, це те
звичайний випадок, замість цього це посилання на рядок. Додаток &arg розширює його для вас,
для якого йому потрібен об'єкт makefile як другий параметр.

Якщо ви очікуєте більше аргументів, можливо, у змінному номері, роботу виконує "args".
Цей засіб доступу приймає ті ж 3 параметри, що й arg, а також додаткові параметри:

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

Для поділу використовуються щонайбільше максимум, але принаймні мінімальні коми, присутні перед розширенням
аргументи. Деякі приклади вбудованих функцій makepp:

my( $prefix, $text ) = аргументи $_[0], $_[1], $_[2], 2, 2, 1; # додавання префікса
для мого $cond ( args $_[0], undef, $_[2], ~0 ) ... # і, або
my @args= args $_[0], $_[1], $_[2], ~0, 1, 1; #дзвінок
my( $filters, $words ) = аргументи $_[0], $_[1], $_[2]; # фільтр

Функція повинна повертати скалярний рядок (а не масив), який потім вставляється в
текст на цьому місці.

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

По суті, немає обмежень на те, що може робити функція; Ви можете отримати доступ до файлу, запустити
команди оболонки тощо.

Наразі вирази, що з'являються в залежностях і в діях правила, розширені
один раз, а вирази, що з’являються в цілях, розгортаються двічі, тому будьте обережні, якщо ваш
функція має побічні ефекти і присутня у виразі для цілі.

Зауважте, що середовище (зокрема, cwd), у якому функція оцінює, буде
не обов'язково відповідати середовищу, в якому діють правила з Makefile, в якому
функція була оцінена виконується. Якщо для вас це проблема, то ваша функція
мабуть, має виглядати приблизно так:

sub f_foo {
...
chdir $makefile->{CWD};

... тощо
}

Поклавши Функції в a Perl Модулі
Якщо ви помістили функції у включаючий файл, у вас буде одна копія для кожного Makeppfile
використовує це. Щоб уникнути цього, ви можете написати їх як звичайний модуль Perl з "Exporter"
інтерфейс, і використовуйте його. Це прискорить завантаження та заощадить пам’ять:

perl { використати mymodule }
perl {
використовуйте my::module; # поставте : на новий рядок, щоб це, як правило, не аналізувалося
}

Якщо вам потрібна будь-яка з функцій, зазвичай доступних у файлі Makefile (наприклад, "f_"
функції, "arg" або "args"), ви повинні ввести цей рядок у свій модуль:

використовувати Mpp::Subs;

Недоліком є ​​те, що модуль буде в іншому пакеті, ніж функція безпосередньо
з'являється у make-файлі. Тому вам потрібно передати все як параметри або конструкцію
імена з функцією «виклик» Perl.

покликання зовнішній Perl scripts
Якщо ви викликаєте зовнішній сценарій Perl через «систему» ​​або, як правило, дію, makepp роздвоє a
новий процес (якщо це не остання дія правила) і запустити абсолютно новий інтерпретатор perl.
У цьому немає нічого поганого, крім того, що є більш ефективний спосіб:

&команда аргументи...
Це може бути дію правила. Це викличе функцію команда з префіксом "c_" і
передайте йому решту (необов'язково процитований стиль makepp - не зовсім те саме, що
Shell) аргументи. Якщо таку функцію не знайдено, вона передає всі рядки
«бігти».

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

$(фальшивий викликcmd):
&mycmd 'arg з пробілом' arg2 "arg3" # викликає c_mycmd

%.out: %.in
&myscript -o $(output) $(input) # викликає зовнішній myscript

Ви можете писати свої команди в рамках вбудованих програм, що дозволяють використовувати
ті самі стандартні параметри, що й у них, і обробку введення-виводу, яку вони надають.

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

Кожен власний параметр вказується як "[qw(n name), \$ref, аргумент, під]". Перші два
елементи – це коротке та довге ім’я, за яким слідує посилання на змінну та необов’язково
логічне значення для того, чи приймати аргумент. Без аргументу змінна є
збільшується щоразу, коли надається параметр, інакше значення параметра зберігається в ньому.

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$$_"'"):

sub c_uc {
локальний @ARGV = @_;
Mpp::Cmds::frame {
друкувати "\u\L$_" тоді як <>;
} 'f', qw(i I o O rs);
}

У блоці, обробленому фреймом, ви можете мати вкладені блоки для виконання критичних
операції, як-от відкриття інших файлів.

Mpp::Cmds::perform { ... } 'повідомлення';

Це виведе повідомлення з "--verbose" (яке приймає кожна команда), якщо
команда успішно запущена. Але якщо блок оцінюється як false, він помирає разом
скасовано повідомлення.

пробіг сценарій аргументи...
Це звичайна функція Perl, яку можна використовувати в будь-якому контексті Perl у вашому make-файлі.
Він подібний до системи з кількома аргументами, але в ньому виконується сценарій Perl
поточний процес. Для операторів makepp, функції perl або ваших власних функцій
це процес під запуском makepp. Але для правила, яке виконує підпроцес
це. Сценарій аналізується стільки разів, скільки його викликають, але ви можете додати реальний
працювати з бібліотекою, як це робить pod2html. Ця бібліотека може потім використовуватися на верхньому рівні, тому
що він уже присутній:

perl { use mylib } # розгалужується до всіх правил, які не потребують повторного аналізу

%.out: %.in
makeperl {виконати qw'myscript -o $(output) $(input)'}

Якщо скрипт викликає "exit", закриває стандартні дескриптори файлів або покладається на систему
щоб очистити після нього (відкрити файли, пам'ять...), це може бути проблемою з "запустити". Якщо
Ви викликаєте "run" в операторах або функції perl, makepp може бути порушений або
очищення відбувається лише в кінці makepp.

Якщо у вас є одна з вищезгаданих проблем, запустіть скрипт зовнішньо, тобто з
замість цього командний рядок. У рамках правила очищення є меншою проблемою, особливо ні
як остання дія правила, оскільки підпроцес правила все одно завершиться,
крім Windows.

писемність ваш власний підпис методика
Іноді потрібно, щоб makepp обчислив метод підпису, використовуючи іншу техніку. Для
Наприклад, припустимо, що у вас є двійковий файл, який залежить від спільної бібліотеки. Зазвичай, якщо ви
змінити спільну бібліотеку, вам не потрібно повторно зв’язувати виконувані файли, які залежать від неї, тому що
зв'язування виконується під час виконання. (Однак можливо, що повторне зв’язування виконуваного файлу
може знадобитися, тому я не зробив це значення за замовчуванням.) Що ви хочете makepp
Щоб зробити, це мати той самий підпис для спільної бібліотеки, навіть якщо вона зміниться.

Це можна зробити кількома способами. Найпростіший спосіб – створити свій власний новий
метод підпису (назвемо його «shared_object»). Ви б використали цей метод підпису
лише для правил, які пов’язують двійкові файли, наприклад:

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

Тепер нам потрібно створити метод підпису.

Усі методи підпису повинні бути власними класами, а клас повинен містити кілька спеціальних
елементів (докладніше див. у Mpp/Signature.pm у дистрибутиві). Назва класу має бути
з префіксом "Mpp::Signature::", тому в цьому випадку слід викликати наш клас
"Mpp::Signature::shared_object". Нам потрібно створити файл під назвою shared_object.pm і покласти
це в а Mpp::Підпис каталог десь у Perl include path; найлегше місце
може бути в Mpp/Підпис каталог в установці makepp (наприклад,
/usr/local/share/makepp/Mpp/Signature або де ви його встановили).

Щоб отримати точну інформацію про те, що має пройти в цьому класі, ви повинні уважно переглянути
файлу Mpp/Signature.pm і напевно також Mpp/Signature/exact_match.pm у makepp
розповсюдження. Але в нашому випадку все, що ми хочемо зробити, це внести дуже невелику зміну в an
існуючий механізм підпису; якщо файл є спільною бібліотекою, ми хочемо мати константу
підпис, тоді як якщо файл є чимось іншим, ми хочемо покладатися на makepp normal
механізм підпису. Найкращий спосіб зробити це – успадкувати від
"Mpp::Signature::c_compilation_md5", який зазвичай вибирається методом підпису
коли makepp розпізнає команду посилання.

Отже, файл Mpp/Signature/shared_object.pm може містити наступне:

використовувати суворий;
пакет Mpp::Signature::shared_object;
використовуйте Mpp::Signature::c_compilation_md5;
наш @ISA = qw(Mpp::Signature::c_compilation_md5); # Вкажіть спадщину.
наш $shared_object = благословляє \@ISA; # Частина магії, яка допомагає makepp знайти
# підпрограми для цього методу. всі
# метод підпису повинен мати один із цих.
# Значення не використовується, лише будь-який об'єкт.
# Тепер ось метод, який викликається, коли нам потрібна підпис
# будь-яка ціль або залежність, для яких цей метод підпису активний:
підпідпис {
my ($self, # Це буде те саме, що і $shared_object.
$finfo) = @_; # Спеціальна структура, яка містить все
# makepp знає про цей файл. Побачити
# Mpp/File.pm для деталей.

if ($finfo->{NAME} =~ /\.s[oa]$/) { # Ім’я файлу закінчується на .so чи .sa?
повернути $finfo->file_exists ? 'існує' : '';
# Завжди повертати той самий підпис, якщо файл
# існує. У цьому випадку підписом є
# рядок "існує".
}

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

Цей файл надається як приклад у дистрибутиві makepp, з деякими додатковими
коментарів.

До речі, чому б нам не зробити це за замовчуванням? Ну, бувають випадки, коли змінюють a
спільна бібліотека потребує повторного зв’язування вашої програми. Якщо ви коли-небудь зміните будь-яке
символи, які визначає спільна бібліотека, або символи, які залежать від інших бібліотек
адже іноді може знадобитися повторне посилання.

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

Ще гірше, припустимо, що ви визначили "xyz()" в іншій бібліотеці (викличте її libxyz), подобається це:

my_program: main.o lib1/lib1.so xyz/libxyz.a

Оскільки "libxyz" - це a .a файл, а не a .тому файл, то "xyz()" може не бути завантажено
правильно від libxyz.a якщо ви повторно не зв’яжете свій двійковий файл.

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

Ось деякі інші види методів підпису, які можуть бути корисними, щоб допомогти вам зрозуміти
можливості. Якщо загальне призначення достатньо, деякі з них можуть бути в кінцевому підсумку
включено в makepp:

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

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

static char * date_stamp = "Згенеровано автоматично 01 квітня 2004 ніким";

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

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

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

· Метод підпису для автоматичного вилучення документації, що контролює лише контрольну суму
коментує, що потребує витягувач документації, і ігнорує інші зміни у джерелі
файлу.

Незакінчені
Цей документ ще не закінчений. Він повинен охоплювати, як написати власні сканери для
включити файли та подібні речі.

Використовуйте makepp_extending онлайн за допомогою служб onworks.net