perlpragma - En ligne dans le Cloud

PROGRAMME:

Nom

perlpragma - comment écrire un pragma utilisateur

DESCRIPTION

Un pragma est un module qui influence certains aspects du temps de compilation ou d'exécution
comportement de Perl, comme "strict" ou "warnings". Avec Perl 5.10, vous n'êtes plus
limité au pragmata intégré ; vous pouvez maintenant créer des pragmata utilisateur qui modifient le
comportement des fonctions de l'utilisateur dans une portée lexicale.

A Essentiel (ici)

Par exemple, disons que vous devez créer une classe implémentant des mathématiques surchargées
opérateurs, et aimeriez fournir votre propre pragma qui fonctionne un peu comme "utiliser
entier ;" Vous aimeriez ce code

utiliser MyMaths ;

mon $l = MesMaths->nouveau(1.2);
mon $r = MesMaths->nouveau (3.4);

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

utiliser myint ;
print "B: ", $l + $r, "\n" ;

{
pas de myint ;
print "C: ", $l + $r, "\n" ;
}

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

pas de myint ;
print "E: ", $l + $r, "\n" ;

donner la sortie

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

à, où "utiliser myint;" est en effet, les opérations d'addition sont forcées à un nombre entier, alors que
par défaut, ils ne le sont pas, le comportement par défaut étant restauré via "no myint;"

L'implémentation minimale du package "MyMaths" ressemblerait à ceci :

package MyMaths ;
utiliser des avertissements ;
utiliser strict;
utiliser myint();
utiliser la surcharge '+' => sous {
mon ($l, $r) = @_;
# Passez 1 pour vérifier un niveau d'appel à partir d'ici
si (myint ::en effet(1)) {
entier($$l) + entier($$r);
} Else {
$$l + $$r ;
}
};

sous nouveau {
ma ($classe, $valeur) = @_;
bénir \$value, $class;
}

1;

Notez comment nous chargeons le pragma utilisateur "myint" avec une liste vide "()" pour empêcher son "import"
être appelé.

L'interaction avec la compilation Perl se produit à l'intérieur du package "myint":

paquet myint;

utiliser strict;
utiliser des avertissements ;

sous-importation {
$^H{"myint/in_effect"} = 1 ;
}

sous-unimport {
$^H{"myint/in_effect"} = 0 ;
}

sous in_effect {
mon $level = shift // 0;
mon $hinthash = (appelant($level))[10];
return $hinthash->{"myint/in_effect"} ;
}

1;

Comme les pragmata sont implémentés en tant que modules, comme tout autre module, "use myint;" devient

COMMENCER {
nécessite myint;
myint->import();
}

et "no myint;" est

COMMENCER {
nécessite myint;
myint->unimport();
}

Par conséquent, les routines "import" et "unimport" sont appelées à compiler Paisible pour le code de l'utilisateur.

Les pragmata utilisateur stockent leur état en écrivant dans le hachage magique "%^H", d'où ces deux
les routines le manipulent. Les informations d'état dans "%^H" sont stockées dans l'optree et peuvent être
récupéré en lecture seule au moment de l'exécution avec "caller()", à l'index 10 de la liste des retournés
résultats. Dans l'exemple de pragma, la récupération est encapsulée dans la routine "in_effect()",
qui prend en paramètre le nombre de trames d'appel à remonter pour trouver la valeur du
pragma dans le script de l'utilisateur. Cela utilise "caller()" pour déterminer la valeur de
$^H{"myint/in_effect"} lorsque chaque ligne du script de l'utilisateur a été appelée, et donc
fournir la sémantique correcte dans le sous-programme implémentant l'addition surchargée.

ACTIVITES nommage

Il n'y a qu'un seul "%^H", mais arbitrairement de nombreux modules qui veulent utiliser sa portée
sémantique. Pour éviter de se marcher sur les pieds, ils doivent s'assurer d'utiliser des
clés dans le hachage. Il est donc classique qu'un module n'utilise que des touches commençant
avec le nom du module (le nom de son package principal) et un caractère "/". Après ça
préfixe identifiant le module, le reste de la clé appartient entièrement au module : il peut
inclure n'importe quel caractère. Par exemple, un module "Foo::Bar" devrait utiliser des touches telles
comme "Foo::Bar/baz" et "Foo::Bar/$%/_!". Les modules suivant cette convention jouent tous bien
avec l'un l'autre.

Le noyau Perl utilise une poignée de clés dans "%^H" qui ne suivent pas cette convention, car
ils l'ont précédé. Les clés qui suivent la convention n'entreront pas en conflit avec le noyau
clés historiques.

Mise en œuvre détails

L'optree est partagé entre les threads. Cela signifie qu'il est possible que l'optree
survivra au thread particulier (et donc à l'instance de l'interpréteur) qui a créé
il, donc les vrais scalaires Perl ne peuvent pas être stockés dans l'optree. Au lieu de cela, une forme compacte est utilisée,
qui ne peut stocker que des valeurs entières (signées et non signées), des chaînes ou "undef" -
les références et les valeurs à virgule flottante sont stringified. Si vous devez stocker plusieurs
des valeurs ou des structures complexes, vous devez les sérialiser, par exemple avec "pack". le
la suppression d'une clé de hachage de "%^H" est enregistrée, et comme toujours peut être distinguée de la
existence d'une clé avec la valeur "undef" avec "exists".

Ne pas tenter de stocker des références à des structures de données sous forme d'entiers qui sont récupérés via
"appelant" et reconverti, car cela ne sera pas threadsafe. Les accès seraient au
structure sans verrouillage (ce qui n'est pas sûr pour les scalaires de Perl), et soit la structure
doit fuir, ou il doit être libéré lorsque son thread de création se termine, ce qui peut être
avant que l'optree le référençant est supprimé, si d'autres threads lui survivent.

Utilisez perlpragma en ligne en utilisant les services onworks.net