makepp_extending - Online in de cloud

PROGRAMMA:

NAAM

makepp_extending -- Hoe makepp uit te breiden met Perl

PRODUCTBESCHRIJVING

Makepp is intern flexibel genoeg, zodat u door een klein beetje Perl-code te schrijven dat kunt:
functies toevoegen of een aantal andere bewerkingen uitvoeren.

Algemeen aantekeningen on het schrijven van Perl code naar werk Met makepp
Elke makefile leeft in zijn eigen pakket. Dus definities in één makefile hebben geen invloed op
definities in een andere makefile. Een gemeenschappelijke set functies inclusief alle standaard
tekstuele manipulatiefuncties worden in het pakket geïmporteerd wanneer het wordt gemaakt.

Makefile-variabelen worden opgeslagen als Perl-scalars in dat pakket. (Er zijn uitzonderingen op:
dit: automatische variabelen en de standaardwaarde van variabelen zoals CC zijn eigenlijk:
geïmplementeerd als functies zonder argumenten. Target specifieke vars, opdrachtregel vars en
omgevingsvariabelen worden niet op deze manier gezien.) Dus elke Perl-code die u schrijft, heeft toegang tot alles
makefile-variabelen. Globale variabelen worden opgeslagen in het pakket "Mpp::global". Zien
Makefile-variabelen voor de details.

Elk van de uitspraken (ifperl / ifmakeperl, perl / makeperl, sub / makesub), de
functies (perl / makeperl, map / makemap) en de regelactie (perl / makeperl) voor
Perl-code rechtstreeks in de makefile schrijven is er in twee smaken. De eerste is absoluut
normale Perl, wat betekent dat je het voorvoegsel "f_" moet gebruiken zoals uitgelegd in de volgende sectie, als
u makepp-functies wilt aanroepen. De tweede variant geeft eerst de verklaring door
Variabele expansie in make-stijl, wat betekent dat je de "$"-en moet verdubbelen die Perl moet zien.

Eindafhandeling is speciaal omdat makepp enorme (afhankelijk van je bouwsysteem) gegevens bevat
structuren zouden enkele seconden nodig hebben om het afval te verzamelen met een normale uitgang. Dus we doen een
brute kracht uitgang. In het hoofdproces kun je nog steeds "END" blokken hebben, maar als je die hebt
globale bestandshandles worden ze mogelijk niet gewist. Maar je zou het moderne lexicale moeten gebruiken
filehandles, die goed worden gesloten als ze buiten bereik gaan.

In Perl-code direct uitvoeren als een regelactie of via een commando dat u definieert, het is de
tegenover. "END"-blokken worden niet uitgevoerd, maar globale bestandshandles worden voor u gewist. De
"DESTROY" van globale objecten zal nooit worden uitgevoerd.

Het toevoegen van nieuwe tekstueel functies
U kunt een nieuwe functie aan makepp's repertoire toevoegen door simpelweg een Perl-subroutine van te definiëren
dezelfde naam maar met het voorvoegsel "f_". Bijvoorbeeld:

sub f_mijnfunctie {
mijn $argument = &arg; # Geef het argument een naam.
mijn(undef, $mkfile, $mkfile_line) = @_; # Noem de argumenten.

... doe hier iets

retourneer $return_value;
}

XYZ := $(myfunc mijn func-argumenten)

Als uw functie geen argumenten aanneemt, is er niets aan de hand. Als je functie er één nodig heeft
argument, zoals in het bovenstaande voorbeeld, gebruik de eenvoudige accessor &arg om het te verkrijgen. als jij
meer argumenten verwacht, hebt u de meer complexe accessor "args" nodig die hieronder worden beschreven.

Deze accessors verwerken dezelfde drie parameters die moeten worden doorgegeven aan een "f_"
functie, namelijk de functieargumenten, het makefile-object en een regeldescriptor voor
berichten. Daarom kunt u in het eerste geval het efficiënte &arg-formulier gebruiken.

De &arg-accessor regelt het volgende voor u: Als de argumenten al waren
uitgebreid (bijv. om de naam van de functie te vinden in "$(my$(function) arg)" is de arg
doorgegeven als een string en net teruggekeerd. Als het argument nog moet worden uitgebreid, is dit de:
gebruikelijk geval, is het in plaats daarvan een verwijzing naar een string. De &arg-accessor breidt het voor u uit,
waarvoor het het makefile-object nodig heeft als zijn 2e parameter.

Als u meer argumenten verwacht, mogelijk in variabel aantal, wordt de taak uitgevoerd door "args".
Deze accessor gebruikt dezelfde 3 parameters als arg, plus extra parameters:

max: aantal argumenten (standaard 2): geef ~0 (maxint) voor eindeloos
min: aantal argumenten (standaard 0 als max ~0 is, anders hetzelfde als max)
only_comma: gebruik geen ruimte rond komma's, gebruikelijk voor niet-bestandsnaam

Maximaal max, maar ten minste min komma's aanwezig vóór uitbreiding worden gebruikt om de . te splitsen
argumenten. Enkele voorbeelden van de ingebouwde functies van makepp:

my( $prefix, $text ) = argumenten $_[0], $_[1], $_[2], 2, 2, 1; # voorvoegsel toevoegen
voor mijn $cond ( args $_[0], undef, $_[2], ~0 ) ... # en, of
mijn @args= argumenten $_[0], $_[1], $_[2], ~0, 1, 1; # telefoongesprek
my( $filters, $words ) = args $_[0], $_[1], $_[2]; #filter

De functie moet een scalaire tekenreeks retourneren (geen array) die vervolgens wordt ingevoegd in de
tekst op dat moment.

Als uw functie een fout tegenkomt, moet deze sterven met behulp van de gebruikelijke Perl die-instructie.
Dit wordt opgevangen door makepp en een foutmelding met de bestandsnaam en de regel
nummer van de uitdrukking die de fout veroorzaakt, wordt afgedrukt.

Er zijn in wezen geen grenzen aan wat de functie kan doen; je hebt toegang tot het bestand, run
shell-commando's, enz.

Op dit moment zijn expressies die verschijnen in afhankelijkheden en in de regelacties uitgebreid
één keer, terwijl uitdrukkingen die in doelen verschijnen twee keer worden uitgevouwen, dus wees voorzichtig als je
functie heeft bijwerkingen en is aanwezig in een uitdrukking voor een doelwit.

Merk op dat de omgeving (in het bijzonder de cwd) waarin de functie evalueert, zal
komen niet noodzakelijk overeen met de omgeving waarin de regels uit de Makefile waarin de
functie werd geëvalueerd, worden uitgevoerd. Als dit een probleem voor je is, dan is jouw functie
zou er waarschijnlijk ongeveer zo uit moeten zien:

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

... enz.
}

Putting functies in a Perl module
Als u functies in een include-bestand plaatst, heeft u één exemplaar per Makepp-bestand dat:
gebruikt het. Om dat te voorkomen, kunt u ze schrijven als een normale Perl-module met een "Exporter"
interface, en gebruik die. Dit laadt sneller en bespaart geheugen:

perl { gebruik mijnmodule }
perl {
gebruik mijn::module; # zet : op een nieuwe regel zodat dit niet in de regel wordt geparseerd
}

Als je een van de functies nodig hebt die normaal beschikbaar zijn in een Makefile (zoals de "f_"
functies, "arg" of "args"), moet u deze regel in uw module plaatsen:

gebruik Mpp::Subs;

Het nadeel is dat de module in een ander pakket zou zitten dan direct een functie
verschijnen in een makefile. Dus je moet alles als parameters doorgeven, of construct
namen met Perl's "beller"-functie.

het roepen extern Perl scripts
Als je een extern Perl-script aanroept via "system", of als regel een actie, zal makepp een fork maken
nieuw proces (tenzij het de laatste regelactie is) en start een gloednieuwe perl-interpreter.
Daar is niets mis mee, behalve dat er een efficiëntere manier is:

&commando argumenten ...
Dit kan een regelactie zijn. Het zal een functie aanroepen commando met een "c_" voorvoegsel, en
geef het de rest door (optioneel geciteerde makepp-stijl -- niet precies hetzelfde als
Shell) argumenten. Als een dergelijke functie niet kan worden gevonden, geeft dit alle strings door aan:
"loop".

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

$(nepgesprekcmd):
&mycmd 'arg met spatie' arg2 "arg3" # roept c_mycmd . op

%.uit: %.in
&myscript -o $(output) $(input) # roept externe myscript aan

U kunt uw commando's schrijven binnen het kader van de ingebouwde functies, zodat u gebruik kunt maken van
dezelfde standaardopties als ze hebben, en de I/O-verwerking die ze bieden.

De blokoperator "Mpp::Cmds::frame" wordt gevolgd door een optielijst met één letter van
de ingebouwde elementen (maximaal "qw(fi I ​​o O rs)"). Zelfs als u uw eigen optie specificeert
als u een van deze overschrijft, geeft u nog steeds de enkele letter van de standaardoptie.

Elke eigen optie wordt gespecificeerd als "[qw(n naam), \$ref, arg, sub]". De eerste twee
elementen zijn korte en lange naam, gevolgd door de variabele referentie en optioneel door
een boolean voor het al dan niet aannemen van een argument. Zonder arg is de variabele
verhoogd elke keer dat de optie wordt gegeven, anders wordt de optiewaarde erin opgeslagen.

sub c_my_ocmd { # Typisch uitvoergeval
lokaal @ARGV = @_;
Mpp::Cmds::frame {

... hier iets printen met @ARGV, met opties al automatisch verwijderd

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

sub c_my_icmd { # Typisch invoergeval met 2 opties
lokaal @ARGV = @_;
mijn( $kort, $lang);
Mpp::Cmds::frame {

... doe hier iets met <>

} qw(i I rs), # s specificeert alleen --separator, niet -s
[qw(s short), \$short], # Geen optie arg -> $short == 1
[qw(l lang), \$long, 1, sub { warn "heb arg $long"}];
}

Hier komt een eenvoudige opdracht die alleen het eerste teken van elke invoer in een hoofdletter plaatst
record (gelijk aan "&sed '$$_ = "\u\L$$_"'"):

sub c_uc {
lokaal @ARGV = @_;
Mpp::Cmds::frame {
druk "\u\L$_" af terwijl <>;
} 'f', qw(i I o O rs);
}

Binnen het blok dat per frame wordt afgehandeld, kunt u geneste blokken hebben voor het uitvoeren van kritieke
bewerkingen, zoals het openen van andere bestanden.

Mpp::Cmds::perform { ... } 'bericht';

Dit zal een bericht weergeven met "--verbose" (wat elke opdracht accepteert) als de
opdracht is succesvol uitgevoerd. Maar als het blok als onwaar wordt beoordeeld, sterft het met
ontkend bericht.

lopen script argumenten ...
Dit is een normale Perl-functie die u in elke Perl-context binnen uw makefile kunt gebruiken.
Het is vergelijkbaar met de multi-argumentvorm van systeem, maar het voert het Perl-script uit binnen
het huidige proces. Voor makepp-statements, de perl-functie of uw eigen functies
dat is het proces dat makepp uitvoert. Maar voor een regel die het subproces uitvoert
het. Het script wordt zo vaak geparseerd als het wordt aangeroepen, maar je kunt de echte
werken in een lib, zoals pod2html doet. Deze lib kan dan op het hoogste niveau worden gebruikt, dus
dat het al aanwezig is:

perl { use mylib } # wordt gevorkt naar alle regels die het niet hoeven te repareren

%.uit: %.in
makeperl { voer qw'myscript -o $(output) $(input)'} uit

Als het script "exit" aanroept, sluit dan standaard bestandsdescriptors of vertrouwt op het systeem
om daarna op te ruimen (bestanden openen, geheugen...), kan dit een probleem zijn met "uitvoeren". Indien
je roept "run" in statements of de perl-functie, makepp kan gestoord worden of de
opruimen gebeurt alleen aan het einde van makepp.

Als je een van de bovengenoemde problemen hebt, voer het script dan extern uit, dwz vanaf
de opdrachtregel in plaats daarvan. Binnen een regel is opschonen minder een probleem, vooral niet
als de laatste actie van een regel, aangezien het regelsubproces daarna toch wordt afgesloten,
behalve op Windows.

schrijf- jouw het te bezitten. handtekening methoden
Soms wil je dat makepp een handtekeningmethode berekent met een andere techniek. Voor
Stel dat u een binair bestand hebt dat afhankelijk is van een gedeelde bibliotheek. Normaal gesproken, als u
de gedeelde bibliotheek wijzigen, hoeft u de uitvoerbare bestanden die ervan afhankelijk zijn niet opnieuw te koppelen, omdat
het koppelen gebeurt tijdens runtime. (Het is echter mogelijk dat het opnieuw koppelen van het uitvoerbare bestand
kan nodig zijn, daarom heb ik dit niet als standaard ingesteld.) Wat u wilt makepp
te doen is om dezelfde handtekening voor de gedeelde bibliotheek te hebben, zelfs als deze verandert.

Dit kan op verschillende manieren worden bereikt. De gemakkelijkste manier is om je eigen nieuwe te maken
handtekeningmethode (laten we het "shared_object" noemen). Je zou deze handtekeningmethode gebruiken
alleen op regels die binaire bestanden koppelen, zoals deze:

mijnprogramma: *.o lib1/lib1.so lib2/lib2.so
: handtekening gedeeld_object
$(CC) $(invoer) -o $(uitvoer)

Nu moeten we de handtekeningmethode maken.

Alle ondertekeningsmethoden moeten hun eigen klasse zijn en de klasse moet een paar speciale bevatten
items (zie Mpp/Signature.pm in de distributie voor details). De naam van de klas moet zijn
voorafgegaan door "Mpp::Signature::", dus in dit geval moet onze klasse worden genoemd
"Mpp::Handtekening::shared_object". We moeten een bestand maken met de naam gedeeld_object.pm en zet
het in een Mpp::Handtekening directory ergens in het Perl include-pad; de gemakkelijkste plaats
misschien in de Mpp/handtekening map in de makepp-installatie (bijv.
/usr/local/share/makepp/Mpp/Handtekening of waar je het ook hebt geïnstalleerd).

Voor precieze details over wat er in deze klas moet gebeuren, moet je goed doorlezen
het bestand Mpp/handtekening.pm en waarschijnlijk ook Mpp/handtekening/exact_match.pm in de maak
verdeling. Maar in ons geval willen we alleen maar een heel kleine verandering aanbrengen in een
bestaand ondertekeningsmechanisme; als het bestand een gedeelde bibliotheek is, willen we een constante hebben
handtekening, terwijl als het bestand iets anders is, we willen vertrouwen op makepp's normal
handtekening mechanisme. De beste manier om dit te doen is door te erven van
"Mpp::Signature::c_compilation_md5", de handtekeningmethode die gewoonlijk wordt gekozen
wanneer makepp een linkcommando herkent.

Dus het bestand Mpp/Handtekening/shared_object.pm kan het volgende bevatten:

gebruik strikt;
pakket Mpp::Handtekening::shared_object;
gebruik Mpp::Signature::c_compilation_md5;
onze @ISA = qw(Mpp::Handtekening::c_compilation_md5); # Geef erfenis aan.
onze $shared_object = zegen \@ISA; # Een stukje magie dat makepp helpt te vinden
# de subroutines voor deze methode. Alle
# ondertekeningsmethoden moeten een van deze hebben.
# De waarde wordt niet gebruikt, maar een willekeurig object.
# Dit is de methode die wordt aangeroepen wanneer we de handtekening van nodig hebben
# elk doel of elke afhankelijkheid waarvoor deze handtekeningmethode actief is:
onderhandtekening {
my ($self, # Dit is hetzelfde als $shared_object.
$finfo) = @_; # Een speciale structuur die alles bevat
# makepp is op de hoogte van dit bestand. Zien
# Mpp/File.pm voor details.

if ($finfo->{NAME} =~ /\.s[oa]$/) { # Eindigt de bestandsnaam op .so of .sa?
return $finfo->file_exists ? 'bestaat' : '';
# Retourneer altijd dezelfde handtekening als het bestand
# bestaat. In dit geval is de handtekening de
# tekenreeks "bestaat".
}

Mpp::Handtekening::c_compilation_md5::handtekening;
# Als het bestand niet eindigde op .so of .sa,
# delegeer naar de gebruikelijke handtekeningmethode van makepp.
}

Dit bestand wordt als voorbeeld gegeven in de makepp-distributie, met enkele extra
commentaar.

Trouwens, waarom maken we dit niet standaard? Nou, er zijn momenten waarop je een
gedeelde bibliotheek vereist een nieuwe koppeling van uw programma. Als u ooit de
symbolen die een gedeelde bibliotheek definieert, of de symbolen die afhankelijk zijn van andere bibliotheken
want soms kan een herlink nodig zijn.

Stel bijvoorbeeld dat de gedeelde bibliotheek enkele subroutines aanroept die uw programma
biedt. Stel dat u de gedeelde bibliotheek wijzigt, zodat deze nu een externe aanroept
subroutine "xyz()". Tenzij u de optie "-E" of "--export-dynamic" gebruikt voor de linker
(voor GNU binutils; andere linkers hebben andere optienamen), het symbool "xyz()" mag niet
toegankelijk zijn voor de runtime-linker, zelfs als deze in uw programma bestaat.

Erger nog, stel dat je "xyz()" in een andere bibliotheek hebt gedefinieerd (noem het libxyz), zoals dit:

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

Aangezien "libxyz" a . is .a bestand en niet een .zo bestand, dan kan "xyz()" niet worden ingetrokken
correct van libxyz.a tenzij u uw binaire bestand opnieuw koppelt.

Mpp::Handtekeningmethoden controleren ook niet alleen de tekenreeks die wordt gebruikt om te bepalen of a
bestand is gewijzigd, maar het algoritme dat wordt gebruikt om de strings te vergelijken. Bijvoorbeeld de
handtekeningmethode "target_newer" in de makepp-distributie vereist alleen dat de
doelen nieuwer zijn dan de afhankelijkheden, terwijl de handtekeningmethode "exact_match" (en
alles wat ervan afhangt, zoals "md5" en "c_compilation_md5") vereist dat de
bestand dezelfde handtekening hebben als bij de laatste build.

Hier zijn enkele andere soorten handtekeningmethoden die nuttig kunnen zijn, om u te helpen dit te realiseren:
de mogelijkheden. Als het algemene doel voldoende is, kunnen sommige hiervan uiteindelijk worden
opgenomen in makepp:

· Een handtekeningmethode voor gedeelde bibliotheken die een controlesom retourneert van alle geëxporteerde
symbolen, en ook alle symbolen die het nodig heeft uit andere bibliotheken. Dit lost het probleem op
probleem met bovenstaand voorbeeld, en garandeert onder alle omstandigheden een correcte koppeling.
Er is een experimentele poging gedaan om dit te doen in de makepp-distributie (zie
Mpp/Handtekening/shared_object.pm), maar het werkt alleen met GNU binutils en ELF
bibliotheken op dit moment.

· Een handtekeningmethode die een datumstempel negeert die in een bestand is geschreven. Bijvoorbeeld, als je
genereren een .c bestand automatisch met behulp van een programma dat erop staat een string te plaatsen
op deze manier:

static char * date_stamp = "Automatisch gegenereerd op 01 april 2004 door niemand";

je zou een handtekeningmethode kunnen schrijven die specifiek wijzigingen in datumstempels negeert.
Dus als de datumstempel het enige is dat is veranderd, zal makepp niet opnieuw opbouwen.

· Een handtekeningmethode die de handtekeningen op de normale manier berekent, maar de . negeert
architectuurafhankelijkheid bij de beslissing om te herbouwen. Dit kan handig zijn voor
echt architectuuronafhankelijke bestanden; momenteel als u op één architectuur voortbouwt,
makepp zal aandringen op het opnieuw opbouwen van zelfs architectuuronafhankelijke bestanden wanneer je overstapt
naar een andere architectuur.

· Een handtekeningmethode die opmerkingen in latexbestanden weet te negeren, zoals de
"c_compilation_md5" methode weet hoe opmerkingen in C-bestanden te negeren.

· Een handtekeningmethode voor automatische extractie van documentatie die alleen controlesommen maakt voor de
opmerkingen die een extractor van documentatie nodig heeft en negeert andere wijzigingen in de bron
bestand.

onafgewerkt
Dit document is nog niet klaar. Het zou moeten beschrijven hoe u uw eigen scanners kunt schrijven voor:
inclusief bestanden en dat soort dingen.

Gebruik makepp_extending online met onworks.net-services