makepp_extending - Online în cloud

PROGRAM:

NUME

makepp_extending -- Cum se extinde makepp folosind Perl

DESCRIERE

Makepp este suficient de flexibil în interior, astfel încât, scriind un pic de cod Perl, puteți
adăugați funcții sau efectuați o serie de alte operațiuni.

General notiţe on scris Perl cod la muncă cu makepp
Fiecare makefile trăiește în propriul pachet. Astfel, definițiile dintr-un singur makefile nu afectează
definiții într-un alt makefile. Un set comun de funcții, inclusiv toate standardele
funcțiile de manipulare textuală sunt importate în pachet când este creat.

Variabilele Makefile sunt stocate ca scalari Perl în acel pachet. (Există excepții la
asta: variabilele automate și valoarea implicită a variabilelor precum CC sunt de fapt
implementate ca funcții fără argumente. Țintă anumite vars, vars line de comandă și
mediile de mediu nu sunt văzute în acest fel.) Astfel, orice cod Perl pe care îl scrieți are acces la toate
variabile makefile. Variabilele globale sunt stocate în pachetul „Mpp::global”. Vedea
Variabile Makefile pentru detalii.

Fiecare dintre afirmațiile (ifperl / ifmakeperl, perl / makeperl, sub / makesub),
funcții (perl / makeperl, map / makemap) și acțiunea regulii (perl / makeperl) pentru
scrierea codului Perl direct în fișierul make vine în două variante. Primul este absolut
Perl normal, ceea ce înseamnă că trebuie să utilizați prefixul „f_” așa cum este explicat în secțiunea următoare, dacă
vrei să apelezi funcții makepp. A doua variantă transmite mai întâi declarația
Extindere variabilă în stil Make, ceea ce înseamnă că trebuie să dublezi „$”-urile pe care vrei să le vadă Perl.

Manevrarea finală este specială, deoarece datele uriașe ale makepp (în funcție de sistemul dvs. de construcție).
structurile ar dura câteva secunde pentru a colecta gunoiul cu o ieșire normală. Deci facem a
ieșire în forță brută. În procesul principal puteți avea în continuare blocuri „END”, dar dacă aveți
mânerele globale ale fișierelor s-ar putea să nu fie șters. Dar ar trebui să folosiți lexical modern
filehandle, care se închid corect atunci când ies din domeniul de aplicare.

În codul Perl, rulați direct ca o acțiune de regulă sau printr-o comandă definită de dvs., este
opus. Blocurile „END” nu vor fi executate, dar manerele de fișiere globale sunt eliminate pentru dvs. The
„DISTRUGEREA” obiectelor globale nu va fi niciodată rulată.

Adăugare nou textual funcții
Puteți adăuga o nouă funcție la repertoriul lui makepp prin simpla definire a unei subrutine Perl a
același nume, dar cu prefixul „f_”. De exemplu:

sub f_myfunc {
argumentul meu $ = &arg; # Denumiți argumentul.
my( undef, $mkfile, $mkfile_line ) = @_; # Numiți argumentele.

... fă ceva aici

returnează $return_value;
}

XYZ := $(myfunc my function arguments)

Dacă funcția ta nu acceptă argumente, nu ai nimic de făcut. Dacă funcția ta necesită unul
argument, ca în exemplul de mai sus, utilizați accesoriul simplu &arg pentru a-l obține. daca tu
așteptați mai multe argumente, aveți nevoie de accesoriul mai complex „args” descris mai jos.

Acești accesori procesează aceiași trei parametri care ar trebui să fie trecuți la orice „f_”
funcția, și anume argumentele funcției, obiectul makefile și un descriptor de linie pentru
mesaje. Prin urmare, puteți utiliza formularul eficient &arg în primul caz.

Accesorul &arg are grijă de următoarele pentru dvs.: Dacă argumentele erau deja
extins (de exemplu, pentru a găsi numele funcției în „$(my$(function) arg)” arg este
a trecut ca șir și tocmai a revenit. Dacă argumentul mai are nevoie de extindere, acesta este
caz obișnuit, este în schimb o referire la un șir. Accesoriul &arg îl extinde pentru tine,
pentru care are nevoie de obiectul makefile ca al doilea parametru.

Dacă vă așteptați la mai multe argumente, eventual în număr variabil, lucrarea este efectuată de „args”.
Acest accesor ia aceiași 3 parametri ca arg, plus parametri suplimentari:

max: număr de argumente (implicit 2): da ~0 (maxint) pentru infinit
min: numărul de argumente (implicit 0 dacă max este ~0, altfel la fel ca max)
only_comma: nu consumați spațiu în jurul virgulelor, de obicei pentru non-nume de fișier

Cel mult max, dar cel puțin min virgulele prezente înainte de extindere sunt folosite pentru a împărți
argumente. Câteva exemple din funcțiile încorporate ale makepp:

my( $prefix, $text ) = argumente $_[0], $_[1], $_[2], 2, 2, 1; # addprefix
pentru $cond (args $_[0], undef, $_[2], ~0) ... # și sau
my @args= args $_[0], $_[1], $_[2], ~0, 1, 1; # apel
my( $filtre, $cuvinte ) = argumente $_[0], $_[1], $_[2]; # filtru

Funcția ar trebui să returneze un șir scalar (nu o matrice) care este apoi inserat în
text în acel moment.

Dacă funcția dvs. întâlnește o eroare, aceasta ar trebui să dispară folosind instrucțiunea obișnuită Perl die.
Acest lucru va fi captat de makepp și de un mesaj de eroare care afișează numele fișierului și linia
numărul expresiei care provoacă eroarea va fi tipărit.

În esență, nu există limite cu privire la ceea ce poate face funcția; puteți accesa fișierul, rulați
comenzi shell etc.

În prezent, expresiile care apar în dependențe și în acțiunile de regulă sunt extinse
o dată în timp ce expresiile care apar în ținte sunt extinse de două ori, așa că aveți grijă dacă dvs
funcția are efecte secundare și este prezentă într-o expresie pentru o țintă.

Rețineți că mediul (în special, cwd) în care funcția evaluează va
nu se potrivesc neapărat cu mediul în care regulile din Makefile în care
funcția a fost evaluată sunt executate. Dacă aceasta este o problemă pentru tine, atunci funcția ta
probabil ar trebui să arate cam așa:

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

... etc
}

Punând funcții în a Perl modul
Dacă puneți funcții într-un fișier include, veți avea o copie per Makeppfile care
îl folosește. Pentru a evita acest lucru, le puteți scrie ca un modul Perl normal cu un „Exportator”
interfață și folosește-o. Aceasta se va încărca mai repede și va economisi memorie:

perl { folosește modulul meu }
perl {
utilizați modulul meu::; # put : pe o linie nouă, astfel încât aceasta să nu fie analizată ca regulă
}

Dacă aveți nevoie de oricare dintre funcțiile disponibile în mod normal într-un Makefile (cum ar fi „f_”
funcții, „arg” sau „args”), trebuie să puneți această linie în modulul dvs.:

utilizați Mpp::Subs;

Dezavantajul este că modulul ar fi într-un pachet diferit de o funcție directă
care apar într-un makefile. Deci, trebuie să treceți totul ca parametri sau construiți
nume cu funcția „apelant” a lui Perl.

apel extern Perl script-uri
Dacă apelați un script Perl extern prin „sistem”, sau ca o acțiune de regulă, makepp va bifurca a
proces nou (cu excepția cazului în care este ultima acțiune de regulă) și declanșează un interpret perl nou-nouț.
Nu este nimic în neregulă cu asta, cu excepția faptului că există o modalitate mai eficientă:

&comandă argumente ...
Aceasta poate fi o acțiune de regulă. Va apela o funcție comandă cu un prefix „c_” și
transmiteți-i restul (stilul makepp citat opțional -- nu exact la fel ca
Shell) argumente. Dacă o astfel de funcție nu poate fi găsită, aceasta trece toate șirurile către
"alerga".

sub c_mycmd { my @args = @_; ...}

$(callcmd fals):
&mycmd „arg cu spațiu” arg2 „arg3” # apelează c_mycmd

%.afara in
&myscript -o $(ieșire) $(input) # apelează myscript extern

Vă puteți scrie comenzile în cadrul integratelor, permițându-vă să le utilizați
aceleași opțiuni standard pe care le au și gestionarea I/O pe care o oferă.

Operatorul bloc „Mpp::Cmds::frame” este urmat de o listă de opțiuni cu o singură literă de
încorporații (maximum „qw(fi I ​​o O rs)”). Chiar dacă specificați propria opțiune
depășind unul dintre acestea, dați în continuare litera unică a opțiunii standard.

Fiecare opțiune proprie este specificată ca „[qw(n nume), \$ref, arg, sub]". Primele două
elementele sunt nume scurt și lung, urmat de referința variabilei și opțional de
un boolean pentru a stabili dacă să acceptăm un argument. Fără un arg, variabila este
incrementat de fiecare dată când este dată opțiunea, altfel valoarea opțiunii este stocată în ea.

sub c_my_ocmd { # Caz de ieșire tipic
local @ARGV = @_;
Mpp::Cmds::frame {

... imprimați ceva aici cu @ARGV, cu opțiunile deja eliminate automat

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

sub c_my_icmd { # Caz de intrare tipic cu 2 opțiuni
local @ARGV = @_;
my( $scurt, $lung );
Mpp::Cmds::frame {

... fă ceva aici cu <>

} qw(i I rs), # s specifică doar --separator, nu -s
[qw(s short), \$short], # Nicio opțiune arg -> $short == 1
[qw(l long), \$long, 1, sub { warn "got arg $long"}];
}

Aici vine o comandă simplă care pune majuscule doar primul caracter al fiecărei intrări
înregistrare (echivalent cu „&sed '$$_ = "\u\L$$_"'"):

sub c_uc {
local @ARGV = @_;
Mpp::Cmds::frame {
imprimă „\u\L$_” în timp ce <>;
} 'f', qw(i I o O rs);
}

În cadrul blocului gestionat de cadru, puteți avea blocuri imbricate pentru a efectua activități critice
operațiuni, cum ar fi deschiderea altor fișiere.

Mpp::Cmds::perform { ... } „mesaj”;

Acest lucru va afișa mesajul cu „--verbose” (pe care fiecare comandă îl acceptă) dacă
comanda este executată cu succes. Dar dacă blocul este evaluat ca fiind fals, moare cu
mesaj negat.

alerga scenariu argumente ...
Aceasta este o funcție Perl normală pe care o puteți utiliza în orice context Perl din cadrul fișierului dvs. make.
Este similar cu forma cu mai multe argumente a sistemului, dar rulează scriptul Perl în interior
procesul curent. Pentru instrucțiunile makepp, funcția perl sau propriile funcții
acesta este procesul care rulează makepp. Dar pentru o regulă, acesta este subprocesul care funcționează
aceasta. Scriptul este analizat de câte ori este apelat, dar puteți pune realul
lucrează într-o lib, așa cum face pod2html. Această lib poate fi folosită apoi la nivelul superior, deci
ca este deja prezent:

perl { folosește mylib } # devine bifurcat la toate regulile care nu trebuie să le analizeze

%.afara in
makeperl { rulați qw'myscript -o $(ieșire) $(intrare)'}

Dacă scriptul apelează „exit”, închide descriptorii de fișiere standard sau se bazează pe sistem
pentru a curăța după el (fișiere deschise, memorie...), aceasta poate fi o problemă cu „run”. Dacă
apelați „run” în cadrul instrucțiunilor sau al funcției perl, makepp poate fi deranjat sau
curățarea are loc doar la sfârșitul makepp.

Dacă aveți una dintre problemele menționate mai sus, rulați scriptul extern, adică de la
în schimb linia de comandă. Într-o regulă, curățarea este mai puțin o problemă, mai ales că nu
ca ultima acțiune a unei reguli, deoarece subprocesul de regulă va ieși oricum ulterior,
cu excepția Windows.

Scris ta propriu semnătură Metode
Uneori doriți ca makepp să calculeze o metodă de semnătură folosind o tehnică diferită. Pentru
de exemplu, să presupunem că aveți un binar care depinde de o bibliotecă partajată. De obicei, dacă tu
schimbați biblioteca partajată, nu trebuie să reconectați executabilele care depind de ea deoarece
legătura se face în timpul executării. (Cu toate acestea, este posibil ca reconectarea executabilului
ar putea fi necesar, motiv pentru care nu am făcut acest lucru implicit.) Ce vrei makepp
este să aveți aceeași semnătură pentru biblioteca partajată, chiar dacă aceasta se schimbă.

Acest lucru poate fi realizat în mai multe moduri. Cel mai simplu mod este să-ți creezi propriul nou
metoda semnăturii (să o numim „shared_object”). Veți folosi această metodă de semnătură
numai pe reguli care leagă binare, ca aceasta:

myprogram : *.o lib1/lib1.so lib2/lib2.so
: semnătură shared_object
$(CC) $(intrări) -o $(ieșire)

Acum trebuie să creăm metoda semnăturii.

Toate metodele de semnătură trebuie să fie propria lor clasă, iar clasa trebuie să conțină câteva speciale
articole (a se vedea Mpp/Signature.pm în distribuție pentru detalii). Numele clasei trebuie să fie
prefixat cu „Mpp::Signature::”, deci în acest caz clasa noastră ar trebui să fie apelată
„Mpp::Semnătură::shared_object”. Trebuie să creăm un fișier numit obiect_partajat.pm si pune
o într-o Mpp::Semnătura directorul undeva în calea include Perl; cel mai usor loc
ar putea fi în Mpp/Semnătură directorul din instalarea makepp (de exemplu,
/usr/local/share/makepp/Mpp/Signature sau oriunde l-ați instalat).

Pentru detalii precise despre ceea ce trebuie să meargă în această clasă, ar trebui să priviți cu atenție
fișierul Mpp/Semnătură.pm si probabil si Mpp/Semnătură/exact_match.pm în makepp
distributie. Dar în cazul nostru, tot ceea ce vrem să facem este să facem o schimbare foarte mică la un
mecanism de semnătură existent; dacă fișierul este o bibliotecă partajată, dorim să avem o constantă
semnătură, în timp ce dacă fișierul este altceva, vrem să ne bazăm pe normalul lui makepp
mecanism de semnătură. Cel mai bun mod de a face acest lucru este de a moșteni de la
„Mpp::Signature::c_compilation_md5”, care este metoda de semnătură care este de obicei aleasă
când makepp recunoaște o comandă link.

Deci dosarul Mpp/Semnătură/shared_object.pm poate conține următoarele:

folosiți strict;
pachet Mpp::Signature::shared_object;
utilizați Mpp::Signature::c_compilation_md5;
nostru @ISA = qw(Mpp::Semnătura::c_compilation_md5); # Indicați moștenirea.
nostru $shared_object = binecuvântează \@ISA; # O bucată de magie care îl ajută pe makepp să găsească
# subprogramele pentru această metodă. Toate
# metode de semnătură trebuie să aibă una dintre acestea.
# Valoarea nu este folosită, doar orice obiect.
# Acum iată metoda care este apelată atunci când avem nevoie de semnătura lui
# orice țintă sau dependență pentru care această metodă de semnătură este activă:
subsemnătură {
my ($self, # Acesta va fi același cu $shared_object.
$finfo) = @_; # O structură specială care conține totul
# makepp știe despre acest fișier. Vedea
# Mpp/File.pm pentru detalii.

if ($finfo->{NAME} =~ /\.s[oa]$/) { # Numele fișierului se termină în .so sau .sa?
returnează $finfo->file_exists ? 'există': '';
# Returnați întotdeauna aceeași semnătură dacă fișierul
# există. În acest caz, semnătura este
# șir „există”.
}

Mpp::Semnătură::c_compilation_md5::semnătură;
# Dacă fișierul nu s-a terminat în .so sau .sa,
# delegat la metoda obișnuită de semnătură a makepp.
}

Acest fișier este oferit ca exemplu în distribuția makepp, cu unele suplimentare
comentarii.

De altfel, de ce nu facem acest lucru implicit? Ei bine, există momente când se schimbă un
biblioteca partajată va necesita o reconectare a programului dvs. Dacă schimbați vreodată vreunul
simbolurile pe care o bibliotecă partajată le definește sau simbolurile pe care aceasta le depinde de alte biblioteci
pentru că uneori poate fi necesară o reconectare.

Să presupunem, de exemplu, că biblioteca partajată invocă unele subrutine pe care programul dumneavoastră
prevede. De exemplu, să presupunem că schimbați biblioteca partajată, astfel încât acum apelează un extern
subrutina „xyz()”. Cu excepția cazului în care utilizați opțiunea „-E” sau „--export-dynamic” pentru linker
(pentru GNU binutils; alte linkere au nume de opțiuni diferite), simbolul „xyz()” poate să nu fie
să fie accesibil linker-ului de rulare chiar dacă există în programul dumneavoastră.

Și mai rău, să presupunem că ați definit „xyz()” într-o altă bibliotecă (numiți-o libxyz), asa:

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

Deoarece „libxyz” este a .a dosar și nu a .asa de fișier, atunci „xyz()” poate să nu fie introdus
corect din libxyz.a cu excepția cazului în care reconectați binarul.

Metodele Mpp::Signature controlează, de asemenea, nu numai șirul care este utilizat pentru a determina dacă a
fișierul s-a schimbat, dar algoritmul care este folosit pentru a compara șirurile. De exemplu, cel
metoda semnăturii „target_newer” din distribuția makepp necesită doar ca
obiectivele să fie mai noi decât dependențele, în timp ce metoda semnăturii „exact_match” (și
tot ceea ce depinde de el, cum ar fi „md5” și „c_compilation_md5”) necesită ca
fișierul are aceeași semnătură ca la ultima versiune.

Iată câteva alte tipuri de metode de semnătură care ar putea fi utile, pentru a vă ajuta să realizați
posibilitatile. Dacă un scop general este suficient, unele dintre acestea pot fi în cele din urmă
încorporat în makepp:

· O metodă de semnătură pentru bibliotecile partajate care returnează o sumă de control a tuturor celor exportate
simboluri, precum și toate simbolurile de care are nevoie din alte biblioteci. Aceasta rezolvă problema
problemă cu exemplul de mai sus și garantează o legătură corectă în toate circumstanțele.
S-a făcut o încercare experimentală de a face acest lucru în distribuția makepp (vezi
Mpp/Semnătură/shared_object.pm), dar va funcționa numai cu GNU binutils și ELF
biblioteci în acest moment.

· O metodă de semnătură care ignoră o ștampilă de dată scrisă într-un fișier. De exemplu, dacă tu
genera o .c fișier automat folosind un program care insistă să pună un șir
in asa:

static char * date_stamp = "Generat automat la 01 aprilie 2004 de nimeni";

ați putea scrie o metodă de semnătură care ignoră în mod specific modificările în ștampilele datei.
Astfel, dacă ștampila dată este singurul lucru care s-a schimbat, makepp nu se va reconstrui.

· O metodă de semnătură care calculează semnăturile în mod normal, dar ignoră
dependența de arhitectură atunci când decideți dacă să reconstruiți. Acest lucru ar putea fi util pentru
fișiere cu adevărat independente de arhitectură; în prezent, dacă construiți pe o singură arhitectură,
makepp va insista să reconstruiască chiar și fișierele independente de arhitectură atunci când comutați
la o arhitectură diferită.

· O metodă de semnătură care știe cum să ignore comentariile din fișierele latex, cum ar fi
Metoda „c_compilation_md5” știe cum să ignore comentariile din fișierele C.

· O metodă de semnătură pentru extragerea automată a documentației care sume de control numai pentru
comentează că un extractor de documentație are nevoie și ignoră alte modificări ale sursei
fișier.

Neterminat
Acest document nu este încă finalizat. Ar trebui să acopere cum să scrieți propriile scanere pentru
include fișiere și lucruri de genul ăsta.

Utilizați makepp_extending online folosind serviciile onworks.net