makepp_extending - Online sa Cloud

PROGRAMA:

NAME

makepp_extending -- Paano palawigin ang makepp gamit ang Perl

DESCRIPTION

Ang panloob na Makepp ay sapat na nababaluktot upang sa pamamagitan ng pagsulat ng kaunting Perl code, magagawa mo
magdagdag ng mga function o gumawa ng maraming iba pang mga operasyon.

Pangkalahatan mga tala on pagsulat Perl code sa trabaho sa makepp
Ang bawat makefile ay nabubuhay sa sarili nitong pakete. Kaya ang mga kahulugan sa isang makefile ay hindi nakakaapekto
mga kahulugan sa isa pang makefile. Isang karaniwang hanay ng mga function kasama ang lahat ng pamantayan
Ang textual manipulation function ay ini-import sa package kapag ito ay ginawa.

Ang mga variable ng Makefile ay iniimbak bilang Perl scalar sa package na iyon. (May mga pagbubukod sa
ito: ang mga awtomatikong variable at ang default na halaga ng mga variable tulad ng CC ay talagang
ipinatupad bilang mga function na walang mga argumento. Mag-target ng mga partikular na vars, command line vars at
environment vars ay hindi nakikita sa ganitong paraan.) Kaya ang anumang Perl code na isusulat mo ay may access sa lahat
mga variable ng makefile. Ang mga pandaigdigang variable ay iniimbak sa "Mpp::global" na pakete. Tingnan mo
Makefile variable para sa mga detalye.

Ang bawat isa sa mga pahayag (ifperl / ifmakeperl, perl / makeperl, sub / makesub), ang
function (perl / makeperl, mapa / makemap) at ang pagkilos ng panuntunan (perl / makeperl) para sa
Ang pagsulat ng Perl code nang direkta sa makefile ay may dalawang lasa. Ang una ay ganap
normal Perl, ibig sabihin kailangan mong gamitin ang prefix na "f_" gaya ng ipinaliwanag sa susunod na seksyon, kung
gusto mong tawagan ang mga function ng makepp. Ang pangalawang variant ay unang pumasa sa pahayag
Make-style na variable expansion, ibig sabihin, kailangan mong doblehin ang "$" na gusto mong makita ni Perl.

Espesyal ang end handling dahil napakalaking data ng makepp (depende sa iyong build system).
ang mga istruktura ay tatagal ng ilang segundo sa pagkolekta ng basura na may normal na labasan. Kaya ginagawa namin ang isang
brute force exit. Sa pangunahing proseso maaari ka pa ring magkaroon ng "END" blocks ngunit kung mayroon ka man
pandaigdigang file ang humahawak na maaaring hindi sila ma-flush. Ngunit dapat mong gamitin ang modernong leksikal
filehandles, na nakasasara nang maayos kapag lumalabas sa saklaw.

Sa Perl code tumakbo nang direkta bilang isang panuntunan aksyon o sa pamamagitan ng isang command na iyong tinukoy, ito ay ang
kabaligtaran. Ang mga "END" na bloke ay hindi tatakbo, ngunit ang mga pandaigdigang filehandle ay mapupula para sa iyo. Ang
Hindi kailanman tatakbo ang "DESTROY" ng mga pandaigdigang bagay.

Pagdaragdag bago tekstuwal function
Maaari kang magdagdag ng bagong function sa makepp's repertoire sa pamamagitan lamang ng pagtukoy sa isang Perl subroutine ng
ang parehong pangalan ngunit may prefix ng "f_". Halimbawa:

sub f_myfunc {
aking $argumento = &arg; # Pangalanan ang argumento.
my( undef, $mkfile, $mkfile_line ) = @_; # Pangalanan ang mga argumento.

... gumawa ng isang bagay dito

ibalik ang $return_value;
}

XYZ := $(myfunc my func arguments)

Kung ang iyong function ay walang mga argumento, walang dapat gawin. Kung ang iyong function ay tumatagal ng isa
argumento, tulad ng sa halimbawa sa itaas, gamitin ang simpleng accessor &arg upang makuha ito. kung ikaw
asahan ang higit pang mga argumento, kailangan mo ang mas kumplikadong accessor na "args" na inilarawan sa ibaba.

Pinoproseso ng mga accessor na ito ang parehong tatlong parameter na dapat ipasa sa anumang "f_"
function, lalo na ang function arguments, ang makefile object at isang line descriptor para sa
mga mensahe. Samakatuwid maaari mong gamitin ang mahusay na &arg form sa unang kaso.

Ang &arg accessor ang bahala sa mga sumusunod para sa iyo: Kung ang mga argumento ay na
pinalawak (hal. upang mahanap ang pangalan ng function sa "$(my$(function) arg)" ang arg ay
pumasa bilang isang string at bumalik lamang. Kung ang argumento ay nangangailangan pa rin ng pagpapalawak, ito ay ang
karaniwang kaso, ito ay sa halip ay isang sanggunian sa isang string. Pinapalawak ito ng &arg accessor para sa iyo,
kung saan kailangan nito ang makefile object bilang 2nd parameter nito.

Kung inaasahan mo ang higit pang mga argumento, posibleng sa variable na numero, ang trabaho ay isinasagawa ng "args".
Ang accessor na ito ay tumatagal ng parehong 3 parameter gaya ng arg, kasama ang mga karagdagang parameter:

max: bilang ng mga args (default 2): magbigay ng ~0 (maxint) para sa walang katapusang
min: bilang ng mga args (default 0 kung ang max ay ~0, kung hindi ay pareho ng max)
only_comma: huwag kumain ng espasyo sa paligid ng mga kuwit, karaniwan para sa hindi filename

Pinakamataas, ngunit hindi bababa sa min na mga kuwit bago ang pagpapalawak ay ginagamit upang hatiin ang
mga argumento. Ilang halimbawa mula sa mga builtin na function ng makepp:

my( $prefix, $text ) = args $_[0], $_[1], $_[2], 2, 2, 1; # addprefix
para sa aking $cond ( args $_[0], undef, $_[2], ~0 ) ... # at, o
my @args= args $_[0], $_[1], $_[2], ~0, 1, 1; # tawag
my( $filter, $words ) = args $_[0], $_[1], $_[2]; # filter

Ang function ay dapat magbalik ng isang scalar string (hindi isang array) na pagkatapos ay ipinasok sa
text sa puntong iyon.

Kung ang iyong function ay nakatagpo ng isang error, dapat itong mamatay gamit ang karaniwang Perl die statement.
Makukulong ito ng makepp at isang mensahe ng error na nagpapakita ng pangalan ng file at linya
numero ng expression na sanhi ng error ay ipi-print out.

Sa katunayan, walang mga limitasyon sa kung ano ang maaaring gawin ng function; maaari mong ma-access ang file, tumakbo
mga utos ng shell, atbp.

Sa kasalukuyan, pinalawak ang mga expression na lumalabas sa mga dependency at sa mga pagkilos ng panuntunan
isang beses habang ang mga expression na lumalabas sa mga target ay pinalawak nang dalawang beses, kaya mag-ingat kung ang iyong
Ang function ay may mga side effect at naroroon sa isang expression para sa isang target.

Tandaan na ang kapaligiran (sa partikular, ang cwd) kung saan sinusuri ng function ay
hindi kinakailangang tumugma sa kapaligiran kung saan ang mga panuntunan mula sa Makefile kung saan ang
function ay nasuri ay naisakatuparan. Kung ito ay isang problema para sa iyo, pagkatapos ay ang iyong function
marahil ay dapat magmukhang ganito:

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

... atbp.
}

Paglalagay function sa a Perl module
Kung maglalagay ka ng mga function sa isang include file, magkakaroon ka ng isang kopya sa bawat Makeppfile na
ginagamit ito. Upang maiwasan iyon, maaari mong isulat ang mga ito bilang isang normal na Perl module na may "Exporter"
interface, at gamitin iyon. Ito ay maglo-load nang mas mabilis at makatipid ng memorya:

perl {gamitin ang mymodule}
perl {
gamitin ang aking::module; # put : sa isang bagong linya kaya hindi ito na-parse bilang panuntunan
}

Kung kailangan mo ng alinman sa mga function na karaniwang magagamit sa isang Makefile (tulad ng "f_"
function, "arg" o "args"), dapat mong ilagay ang linyang ito sa iyong module:

gumamit ng Mpp::Subs;

Ang disbentaha ay ang module ay nasa ibang pakete kaysa sa isang function nang direkta
lumalabas sa isang makefile. Kaya kailangan mong ipasa ang lahat bilang mga parameter, o bumuo
mga pangalan na may function na "tumatawag" ni Perl.

Pagtawag panlabas Perl script
Kung tatawagan mo ang isang panlabas na script ng Perl sa pamamagitan ng "system", o bilang isang panuntunang aksyon, ang makepp ay mag-fork a
bagong proseso (maliban kung ito ang huling pagkilos ng panuntunan) at magpaputok ng isang bagong-bagong perl interpreter.
Walang mali doon, maliban na may mas mahusay na paraan:

&utos mga argumento...
Ito ay maaaring isang pagkilos ng panuntunan. Tatawag ito ng isang function utos na may prefix na "c_", at
ipasa ang natitirang (opsyonal na sinipi na istilo ng makepp -- hindi eksaktong kapareho ng
Shell) mga argumento. Kung hindi mahanap ang naturang function, ipinapasa nito ang lahat ng string sa
"tumakbo".

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

$(phony callcmd):
&mycmd 'arg with space' arg2 "arg3" # na tawag sa c_mycmd

%.labas pasok
&myscript -o $(output) $(input) # na tawag sa panlabas na myscript

Maaari mong isulat ang iyong mga utos sa loob ng balangkas ng mga builtin, na nagbibigay-daan sa iyong gamitin
ang parehong mga karaniwang opsyon tulad ng mayroon sila, at ang I/O handling na ibinibigay nila.

Ang block operator na "Mpp::Cmds::frame" ay sinusundan ng isang listahan ng opsyon na titik ng
ang mga builtin (maximally "qw(fi I ​​o O rs)"). Kahit na tukuyin mo ang iyong sariling pagpipilian
sa pag-override sa isa sa mga ito, ibibigay mo pa rin ang isang titik ng karaniwang opsyon.

Ang bawat sariling opsyon ay tinukoy bilang "[qw(n name), \$ref, arg, sub]". Ang unang dalawa
ang mga elemento ay maikli at mahabang pangalan, na sinusundan ng variable na reference at opsyonal ng
isang boolean para sa kung kukuha ng argumento. Kung walang arg, ang variable ay
nadagdagan sa tuwing ibibigay ang opsyon, kung hindi, ang halaga ng opsyon ay nakaimbak dito.

sub c_my_ocmd { # Karaniwang output case
lokal @ARGV = @_;
Mpp::Cmds::frame {

... mag-print ng isang bagay dito gamit ang @ARGV, na may mga opsyon na awtomatikong naalis

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

sub c_my_icmd { # Karaniwang input case na may 2 opsyon
lokal @ARGV = @_;
my( $maikli, $haba);
Mpp::Cmds::frame {

... gumawa ng isang bagay dito gamit ang <>

} qw(i I rs), # s ay tumutukoy lamang --separator, hindi -s
[qw(s short), \$short], # No option arg -> $short == 1
[qw(l long), \$long, 1, sub { warn "got arg $long"}];
}

Narito ang isang simpleng utos na pinapataas lamang ang unang character ng bawat input
record (katumbas ng "&sed '$$_ = "\u\L$$_"'"):

sub c_uc {
lokal @ARGV = @_;
Mpp::Cmds::frame {
i-print ang "\u\L$_" habang <>;
} 'f', qw(i I o O rs);
}

Sa loob ng block na pinangangasiwaan ng frame, maaari kang magkaroon ng mga nested block para sa pagsasagawa ng kritikal
mga operasyon, tulad ng pagbubukas ng iba pang mga file.

Mpp::Cmds::isagawa ang { ... } 'mensahe';

Maglalabas ito ng mensahe na may "--verbose" (na tinatanggap ng bawat utos) kung ang
matagumpay na tumakbo ang command. Ngunit kung ang bloke ay nasuri bilang false, ito ay namamatay
negadong mensahe.

tumakbo script mga argumento...
Ito ay isang normal na function ng Perl na magagamit mo sa anumang konteksto ng Perl sa loob ng iyong makefile.
Ito ay katulad ng multi-argument form ng system, ngunit pinapatakbo nito ang Perl script sa loob
ang kasalukuyang proseso. Para sa mga pahayag ng makepp, ang perl function o ang iyong sariling mga function
iyon ang proseso na tumatakbo sa makepp. Ngunit para sa isang panuntunan na gumaganap ang subprocess
ito. Ang script ay na-parse nang maraming beses hangga't ito ay tinatawag, ngunit maaari mong ilagay ang tunay
gumana sa isang lib, tulad ng ginagawa ng pod2html. Ang lib na ito ay maaaring magamit sa pinakamataas na antas, kaya
na ito ay naroroon na:

perl { use mylib } # ay nakukuha sa lahat ng mga panuntunan na hindi na kailangang i-reparse ito

%.labas pasok
makeperl { run qw'myscript -o $(output) $(input)' }

Kung ang script ay tinatawag na "lumabas", isasara ang mga karaniwang file descriptor o umaasa sa system
upang linisin pagkatapos nito (bukas na mga file, memorya...), maaari itong maging problema sa "run". Kung
tinatawag mong "run" sa loob ng mga pahayag o ang perl function, maaaring maabala ang makepp o ang
Ang paglilinis ay nangyayari lamang sa dulo ng makepp.

Kung mayroon kang isa sa mga nabanggit na problema, patakbuhin ang script sa labas, ibig sabihin, mula sa
ang command line sa halip. Sa loob ng isang panuntunan, ang paglilinis ay hindi gaanong problema, lalo na hindi
bilang huling pagkilos ng isang panuntunan, dahil lalabas din ang subprocess ng panuntunan pagkatapos,
maliban sa Windows.

Pagsulat iyong sarili lagda pamamaraan
Minsan gusto mong kalkulahin ng makepp ang isang signature method gamit ang ibang technique. Para sa
halimbawa, ipagpalagay na mayroon kang isang binary na nakadepende sa isang nakabahaging library. Karaniwan, kung ikaw
baguhin ang nakabahaging library, hindi mo na kailangang i-link muli ang mga executable na nakasalalay dito dahil
ang pag-link ay tapos na sa oras ng pagtakbo. (Gayunpaman, posible na muling i-link ang executable
Maaaring kailanganin, kaya hindi ko ito ginawang default.) Ano ang gusto mong makepp
ang gagawin ay magkaroon ng parehong lagda para sa nakabahaging aklatan kahit na ito ay magbago.

Magagawa ito sa maraming paraan. Ang pinakamadaling paraan ay ang gumawa ng sarili mong bago
paraan ng lagda (tawagin natin itong "shared_object"). Gagamitin mo itong signature method
sa mga panuntunan lamang na nagli-link ng mga binary, tulad nito:

myprogram : *.o lib1/lib1.so lib2/lib2.so
: signature shared_object
$(CC) $(inputs) -o $(output)

Ngayon kailangan nating lumikha ng paraan ng lagda.

Ang lahat ng mga pamamaraan ng lagda ay dapat na kanilang sariling klase, at ang klase ay dapat maglaman ng ilang espesyal
aytem (tingnan ang Mpp/Signature.pm sa pamamahagi para sa mga detalye). Ang pangalan ng klase ay dapat
prefixed na may "Mpp::Lagda::", kaya sa kasong ito ang aming klase ay dapat na tinatawag na
"Mpp::Lagda::shared_object". Kailangan nating lumikha ng isang file na tinatawag shared_object.pm at ilagay
ito sa a Mpp::Lagda direktoryo sa isang lugar sa Perl isama ang landas; ang pinakamadaling lugar
maaaring nasa Mpp/Lagda direktoryo sa pag-install ng makepp (hal.,
/usr/local/share/makepp/Mpp/Lagda o kung saan mo ito na-install).

Para sa mga tiyak na detalye tungkol sa kung ano ang dapat gawin sa klase na ito, dapat mong tingnang mabuti
mga file Mpp/Lagda.pm at malamang din Mpp/Lagda/exact_match.pm sa makepp
pamamahagi. Ngunit sa aming kaso, ang gusto lang naming gawin ay gumawa ng napakaliit na pagbabago sa isang
umiiral na mekanismo ng lagda; kung ang file ay isang shared library, gusto naming magkaroon ng pare-pareho
signature, samantalang kung iba ang file, gusto naming umasa sa normal ng makepp
mekanismo ng lagda. Ang pinakamahusay na paraan upang gawin ito ay magmana mula sa
"Mpp::Signature::c_compilation_md5", na siyang paraan ng signature na karaniwang pinipili
kapag nakilala ng makepp ang isang link na utos.

Kaya ang file Mpp/Lagda/shared_object.pm maaaring naglalaman ng sumusunod:

gumamit ng mahigpit;
package Mpp::Lagda::shared_object;
gumamit ng Mpp::Lagda::c_compilation_md5;
aming @ISA = qw(Mpp::Lagda::c_compilation_md5); # Ipahiwatig ang mana.
aming $shared_object = bless \@ISA; # Isang piraso ng magic na tumutulong sa makepp na mahanap
# ang mga subroutine para sa pamamaraang ito. Lahat
Ang # signature na pamamaraan ay dapat magkaroon ng isa sa mga ito.
# Ang halaga ay hindi ginagamit, anumang bagay lamang.
# Ngayon narito ang paraan na tatawagin kapag kailangan namin ng lagda ng
# anumang target o dependency kung saan aktibo ang signature method na ito:
sub signature {
my ($self, # Ito ay magiging kapareho ng $shared_object.
$finfo) = @_; # Isang espesyal na istraktura na naglalaman ng lahat
Alam ng # makepp ang tungkol sa file na ito. Tingnan mo
# Mpp/File.pm para sa mga detalye.

if ($finfo->{NAME} =~ /\.s[oa]$/) { # Nagtatapos ba ang pangalan ng file sa .so o .sa?
ibalik ang $finfo->file_exists ? 'umiiral' : '';
# Palaging ibalik ang parehong pirma kung ang file
# umiiral. Sa kasong ito, ang pirma ay ang
# string na "umiiral".
}

Mpp::Lagda::c_compilation_md5::pirma;
# Kung ang file ay hindi nagtatapos sa .so o .sa,
# italaga sa karaniwang paraan ng lagda ng makepp.
}

Ang file na ito ay ibinigay bilang isang halimbawa sa pamamahagi ng makepp, na may ilang karagdagang
mga komento.

Hindi sinasadya, bakit hindi natin ito gawing default? Well, may mga pagkakataon na nagbabago a
ang shared library ay mangangailangan ng muling pag-link ng iyong programa. Kung sakaling baguhin mo ang alinman sa
mga simbolo na tinutukoy ng isang nakabahaging aklatan, o ang mga simbolo na nakasalalay sa ibang mga aklatan
dahil, maaaring kailanganin minsan ang muling pag-link.

Ipagpalagay, halimbawa, na ang nakabahaging library ay nag-invoke ng ilang subroutine na iyong program
nagbibigay. Halimbawa, ipagpalagay na binago mo ang nakabahaging aklatan upang tumawag ito ngayon ng isang panlabas
subroutine "xyz()". Maliban kung gagamitin mo ang opsyong "-E" o "--export-dynamic" sa linker
(para sa mga binutil ng GNU; iba pang mga linker ay may iba't ibang pangalan ng opsyon), ang simbolo na "xyz()" ay maaaring hindi
maging accessible sa run-time na linker kahit na mayroon ito sa iyong programa.

Mas masahol pa, ipagpalagay na tinukoy mo ang "xyz()" sa isa pang library (tawagan ito libxyz), ganito:

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

Dahil ang "libxyz" ay isang .a file at hindi a .so file, pagkatapos ay maaaring hindi makuha ang "xyz()".
tama mula sa libxyz.a maliban kung i-relink mo ang iyong binary.

Mpp::Ang mga pamamaraan ng lagda ay kinokontrol din hindi lamang ang string na ginagamit upang matukoy kung a
file ay nagbago, ngunit ang algorithm na ginagamit upang ihambing ang mga string. Halimbawa, ang
signature method na "target_newer" sa makepp distribution ay nangangailangan lamang na ang
ang mga target ay mas bago kaysa sa mga dependency, samantalang ang signature method na "exact_match" (at
lahat ng nakasalalay dito, tulad ng "md5" at "c_compilation_md5") ay nangangailangan na ang
file ay may parehong lagda tulad ng sa huling build.

Narito ang ilang iba pang mga uri ng signature na pamamaraan na maaaring maging kapaki-pakinabang, upang matulungan kang maunawaan
ang mga posibilidad. Kung sapat ang pangkalahatang layunin, ang ilan sa mga ito ay maaaring sa kalaunan
isinama sa makepp:

· Isang paraan ng lagda para sa mga shared library na nagbabalik ng checksum ng lahat ng na-export
mga simbolo, at gayundin ang lahat ng mga simbolo na kailangan nito mula sa iba pang mga aklatan. Nalulutas nito ang
problema sa halimbawa sa itaas, at ginagarantiyahan ang isang tamang link sa ilalim ng lahat ng pagkakataon.
Ang isang eksperimentong pagtatangka ay ginawa upang gawin ito sa pamamahagi ng makepp (tingnan
Mpp/Lagda/shared_object.pm), ngunit gagana lamang ito sa mga GNU binutil at ELF
mga aklatan sa kasalukuyan.

· Isang paraan ng lagda na binabalewala ang isang selyo ng petsa na nakasulat sa isang file. Hal, kung ikaw
bumuo ng a .c awtomatikong file gamit ang ilang program na nagpipilit sa paglalagay ng string
sa ganito:

static char * date_stamp = "Awtomatikong nabuo noong 01 Abr 2004 ng walang sinuman";

maaari kang magsulat ng isang paraan ng lagda na partikular na binabalewala ang mga pagbabago sa mga selyo ng petsa.
Kaya kung ang selyo ng petsa ay ang tanging bagay na nagbago, ang makepp ay hindi muling bubuo.

· Isang paraan ng lagda na kinokwenta ang mga lagda sa normal na paraan, ngunit binabalewala ang
pagdepende sa arkitektura kapag nagpapasya kung muling itatayo. Ito ay maaaring maging kapaki-pakinabang para sa
tunay na architecture-independent na mga file; sa kasalukuyan kung bumuo ka sa isang arkitektura,
pipilitin ng makepp na muling itayo kahit na ang mga file na independyente sa arkitektura kapag lumipat ka
sa ibang arkitektura.

· Isang signature method na alam kung paano balewalain ang mga komento sa latex file, bilang ang
Alam ng pamamaraang "c_compilation_md5" kung paano balewalain ang mga komento sa mga C file.

· Isang paraan ng lagda para sa awtomatikong pagkuha ng dokumentasyon na nagsusuri lamang sa
nagkomento na kailangan ng isang documentation extractor at binabalewala ang iba pang pagbabago sa source
file.

Hindi natapos
Hindi pa tapos ang dokumentong ito. Dapat nitong saklawin kung paano isulat ang iyong sariling mga scanner para sa
isama ang mga file at mga bagay na katulad niyan.

Gumamit ng makepp_extending online gamit ang mga serbisyo ng onworks.net