perlpragma - Online nel cloud

PROGRAMMA:

NOME

perlpragma - come scrivere una pragma utente

DESCRIZIONE

Un pragma è un modulo che influenza qualche aspetto del tempo di compilazione o del tempo di esecuzione
comportamento di Perl, come "strict" o "warnings". Con Perl 5.10 non sei più
limitato ai pragmata integrati; ora puoi creare pragmata utente che modificano il
comportamento delle funzioni utente all'interno di un ambito lessicale.

A basic esempio

Ad esempio, supponiamo che tu debba creare una classe che implementi calcoli matematici sovraccarichi
operatori e vorrei fornire il tuo pragma che funziona in modo molto simile a "use
intero;" Ti piacerebbe questo codice

usa MyMaths;

il mio $l = MyMaths->new(1.2);
il mio $r = MyMaths->new(3.4);

stampa "A: ", $l + $r, "\n";

usa myint;
stampa "B: ", $l + $r, "\n";

{
nessun myint;
stampa "C: ", $l + $r, "\n";
}

stampa "D: ", $l + $r, "\n";

nessun myint;
stampa "E: ", $l + $r, "\n";

per dare l'output

A: 4.6
B: 4
C: 4.6
D: 4
E: 4.6

vale a dire, dove è in vigore "use myint;", le operazioni di addizione sono forzate a numeri interi, mentre
per impostazione predefinita non lo sono, con il comportamento predefinito ripristinato tramite "no myint;"

L'implementazione minima del pacchetto "MyMaths" sarebbe più o meno questa:

pacchetto MyMaths;
utilizzare gli avvisi;
usare rigorosamente;
usa myint();
usa il sovraccarico '+' => sub {
il mio ($l, $r) = @_;
# Passa 1 per controllare un livello di chiamata da qui
se (myint::in_effetto(1)) {
int($$l) + int($$r);
} Else {
$$l + $$r;
}
};

sottonuovo {
il mio ($classe, $valore) = @_;
benedire \$valore, $classe;
}

1;

Nota come carichiamo la direttiva utente "myint" con un elenco vuoto "()" per impedirne l'"importazione"
essere chiamato.

L'interazione con la compilazione Perl avviene all'interno del pacchetto "myint":

pacchetto myint;

usare rigorosamente;
utilizzare gli avvisi;

sotto importazione {
$^H{"myint/in_effect"} = 1;
}

sub non importare {
$^H{"myint/in_effect"} = 0;
}

sub in_effect {
il mio $livello = shift // 0;
mio $hinthash = (chiamante($livello))[10];
return $hinthash->{"myint/in_effect"};
}

1;

Poiché i pragmata sono implementati come moduli, come qualsiasi altro modulo, "use myint;" diventa

INIZIO {
richiedono myint;
myint->import();
}

e "no myint;" è

INIZIO {
richiedono myint;
myint->unimport();
}

Quindi le routine "import" e "unimport" vengono chiamate a compilare tempo per il codice dell'utente.

I pragmata utente memorizzano il loro stato scrivendo nell'hash magico "%^H", quindi questi due
le routine lo manipolano. Le informazioni sullo stato in "%^H" sono memorizzate nell'optree e possono essere
recuperato in sola lettura in fase di esecuzione con "caller()", all'indice 10 dell'elenco dei valori restituiti
risultati. Nell'esempio pragma, il recupero è incapsulato nella routine "in_effect()",
che prende come parametro il numero di frame di chiamata da percorrere per trovare il valore del
pragma nello script dell'utente. Questo utilizza "caller()" per determinare il valore di
$^H{"myint/in_effect"} quando è stata chiamata ogni riga dello script dell'utente e quindi
fornire la semantica corretta nella subroutine che implementa l'addizione sovraccaricata.

Le di denominazione

Esiste un solo "%^H", ma arbitrariamente molti moduli che vogliono utilizzare il suo ambito
semantica. Per evitare di calpestarsi i piedi a vicenda, devono assicurarsi di utilizzare diversi
chiavi nell'hash. È quindi convenzionale per un modulo utilizzare solo chiavi che iniziano
con il nome del modulo (il nome del suo pacchetto principale) e un carattere "/". Dopo questo
prefisso identificativo del modulo, il resto della chiave dipende interamente dal modulo: può
includere qualsiasi carattere. Ad esempio, un modulo "Foo::Bar" dovrebbe usare chiavi come
come "Foo::Bar/baz" e "Foo::Bar/$%/_!". I moduli che seguono questa convenzione funzionano tutti bene
insieme.

Il core Perl utilizza una manciata di chiavi in ​​"%^H" che non seguono questa convenzione, perché
sono precedenti. Le chiavi che seguono la convenzione non entreranno in conflitto con il core
chiavi storiche.

Implementazione/Attuazione dettagli

L'optree è condiviso tra i thread. Ciò significa che esiste la possibilità che l'optree
sopravviverà al thread specifico (e quindi all'istanza dell'interprete) che ha creato
quindi i veri scalari Perl non possono essere memorizzati nell'optree. Viene invece utilizzata una forma compatta,
che può memorizzare solo valori che sono interi (con segno e senza segno), stringhe o "undef" -
i riferimenti e i valori in virgola mobile sono convertiti in stringhe. Se è necessario memorizzare più
valori o strutture complesse, dovresti serializzarli, ad esempio con "pack".
l'eliminazione di una chiave hash da "%^H" viene registrata e, come sempre, può essere distinta dalla
esistenza di una chiave con valore "undef" con "exists".

non tentare di memorizzare i riferimenti alle strutture dati come numeri interi che vengono recuperati tramite
"chiamante" e riconvertito, poiché questo non sarà thread-safe. Gli accessi sarebbero al
struttura senza bloccaggio (che non è sicuro per gli scalari di Perl), e la struttura
deve perdere, oppure deve essere liberato quando il thread di creazione termina, il che può essere
prima che l'optree che vi fa riferimento venga eliminato, se altri thread sopravvivono.

Utilizzare perlpragma online utilizzando i servizi onworks.net