perlpragma - Online nel cloud

PROGRAMMA:

NOME

perlpragma - come scrivere un pragma utente

DESCRIZIONE

Un pragma è un modulo che influenza alcuni aspetti del tempo di compilazione o di esecuzione
comportamento di Perl, come "strict" o "warnings". Con Perl 5.10 non lo sei più
limitato al costruito in pragmata; 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 un sovraccarico matematico
operatori e vorresti fornire il tuo pragma che funzioni in modo molto simile a "usa
intero;" Ti piacerebbe questo codice

usa MyMaths;

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

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

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

{
niente di buono;
stampa "C: ", $l + $r, "\n";
}

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

niente di buono;
print "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 "usa myint;" è in effetti, le operazioni di addizione sono forzate a un numero intero, mentre
per impostazione predefinita non lo sono, con il comportamento predefinito ripristinato tramite "no myint;"

L'implementazione minima del pacchetto "MyMaths" sarebbe qualcosa del genere:

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

sottonuovo {
mia ($classe, $valore) = @_;
benedici \$valore, $classe;
}

1;

Nota come carichiamo il pragma 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;

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

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

sub in_effetto {
mio $livello = shift // 0;
my $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 {
richiedere myint;
myint->import();
}

e "no myint;" è

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

Quindi le routine "import" e "unimport" sono chiamate at compilare tempo per il codice 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 di restituiti
risultati. Nell'esempio pragma, il recupero è incapsulato nella routine "in_effect()",
che prende come parametro il numero di frame di chiamata da salire per trovare il valore di
pragma nello script dell'utente. Questo usa "caller()" per determinare il valore di
$^H{"myint/in_effect"} quando ogni riga dello script dell'utente è stata chiamata, e quindi
fornire la semantica corretta nella subroutine che implementa l'aggiunta in overload.

Le di denominazione

C'è solo un singolo "%^H", ma arbitrariamente molti moduli che vogliono usare il suo ambito
semantica. Per evitare di pestarsi i piedi l'un l'altro, devono essere sicuri di usare 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 "/". Dopodichè
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 usa una manciata di chiavi in ​​"%^H" che non seguono questa convenzione, perché
lo precedono. Le chiavi che seguono la convenzione non entreranno in conflitto con quelle del core
chiavi storiche.

Implementazione/Attuazione dettagli

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

non tentare di memorizzare i riferimenti alle strutture di dati come numeri interi che vengono recuperati tramite
"chiamante" e riconvertito, poiché questo non sarà threadsafe. Gli accessi sarebbero al
struttura senza lock (che non è sicura per gli scalari di Perl), e sia la struttura
deve perdere o deve essere liberato quando il suo thread di creazione termina, il che potrebbe essere
prima che l'optree che lo faccia riferimento venga eliminato, se altri thread sopravvivono.

Utilizzare perlpragma online utilizzando i servizi onworks.net