view release on metacpan or  search on metacpan

FR/perlsub.pod  view on Meta::CPAN

                                                # inséré en ligne aussi ! 

    sub ST_DEV ()       { 0 }
    sub ST_INO ()       { 1 }

    sub FLAG_FOO ()     { 1 << 8 }
    sub FLAG_BAR ()     { 1 << 9 }
    sub FLAG_MASK ()    { FLAG_FOO | FLAG_BAR }

    sub OPT_BAZ ()      { not (0x1B58 & FLAG_MASK) }
    
    sub N () { int(OPT_BAZ) / 3 }

    sub FOO_SET () { 1 if FLAG_MASK & FLAG_FOO }

En revanche, celles qui suivent ne pourront être insérées en ligne ;
parce qu'elles contiennent des choses non constantes dans leur propre
portée.

    sub foo_set () { if (FLAG_MASK & FLAG_FOO) { 1 } }

    sub baz_val () {
        if (OPT_BAZ) {
            return 23;
        }
        else {
            return 42;
        }
    }

Si vous redéfinissez un sous-programmes qui pouvait être inséré en
ligne, vous obtiendrez un avertissement formel (vous pouvez utiliser
cet avertissement pour déterminer si un sous-programme particulier est
considéré comme constant ou pas). L'avertissement est considéré comme
suffisamment sévère pour ne pas être optionnel, car les invocations
précédemment compilées de la fonction utiliseront toujours l'ancienne
valeur de cette fonction. Si vous avez besoin de pouvoir redéfinir le
sous-programme, vous devez vous assurer qu'il n'est pas inséré en
ligne, soit en abandonnant le prototype C<()> (ce qui change la
sémantique de l'appel, donc prenez garde), soit en contrecarrant le
mécanisme d'insertion d'une autre façon, comme par exemple

    sub not_inlined () {
        23 if $];
    }

=head2 Surcharges des fonctions prédéfinies X<prédéfinie> X<fonction prédéfinie> X<surcharge> X<CORE> X<CORE::GLOBAL>

Beaucoup de fonctions prédéfinies peuvent être surchargées, même si
cela ne devrait être essayé qu'occasionnellement et pour une bonne
raison. Typiquement, cela pourrait être réalisé par un paquetage
essayant d'émuler une fonctionnalité prédéfinie manquante sur un
système non Unix.

La surcharge ne peut être réalisée qu'en important le nom depuis un
module lors de la compilation -- la prédéclaration ordinaire n'est pas
suffisante. Toutefois, le pragma C<use subs> vous laisse, dans les
faits, prédéclarer les sous-programmes via la syntaxe d'importation,
et ces noms peuvent ensuite surcharger ceux qui sont prédéfinisE<nbsp>:

    use subs 'chdir', 'chroot', 'chmod', 'chown';
    chdir $somewhere;
    sub chdir { ... }

Pour se référer sans ambiguïté à la forme prédéfinie, on peut faire
précéder le nom prédéfini par le qualificateur de paquetage spéciale
C<CORE::>. Par exemple, le fait de dire C<CORE::open()> se réfère
toujours à la fonction prédéfinie C<open()>, même si le paquetage
courant a importé d'ailleurs un quelconque autre sous-programme appelé
C<&open()>. Même si cela a l'air d'un appel de fonction normal, ce
n'en est pas unE<nbsp>: vous ne pouvez pas en créer de référence, telle que
celles que l'incorrect C<\&CORE::open> pourrait en produire.

Les modules de bibliothèque ne devraient en général pas exporter de
noms prédéfinis comme C<open> ou C<chdir> comme partie de leur liste
C<@EXPORT> par défaut, car ceux-ci pourraient s'infiltrer dans
l'espace de noms de quelqu'un d'autre et changer la sémantique de
façon inattendue. À la place, si le module ajoute ce nom à
C<@EXPORT_OK>, alors il est possible pour un utilisateur d'importer le
nom explicitement, mais pas implicitement. C'est-à-dire qu'il pourrait
dire

    use Module 'open';

et cela importerait la surcharge C<open>. Mais s'il disait

    use Module;

il obtiendrait les importations par défaut sans les surcharges.

Le mécanisme précédent de surcharge des éléments prédéfinis est
restreint, assez délibérément, au paquetage qui réclame l'importation.
Il existe une seconde méthode parfois applicable lorsque vous désirez
surcharger partout une fonction prédéfinie, sans tenir compte des
frontières entre espaces de noms. Cela s'obtient en important un
sous-programme dans l'espace de noms spécial C<CORE::GLOBAL::>. Voici
un exemple qui remplace assez effrontément l'opérateur C<glob> par
quelque chose qui comprend les expressions rationnelles.

    package REGlob;
    require Exporter;
    @ISA = 'Exporter';
    @EXPORT_OK = 'glob';

    sub import {
        my $pkg = shift;
        return unless @_;
        my $sym = shift;
        my $where = ($sym =~ s/^GLOBAL_// ? 'CORE::GLOBAL' : caller(0));
        $pkg->export($where, $sym, @_);
    }

    sub glob {
        my $pat = shift;
        my @got;
        local *D;
        if (opendir D, '.') { 
            @got = grep /$pat/, readdir D; 
            closedir D;   
        }
        return @got;