[Summary view] [Print] [Text view]

   1  package attributes;
   2  
   3  $VERSION = 0.03;
   4  
   5  @EXPORT_OK = qw(get reftype);
   6  @EXPORT = ();
   7  %EXPORT_TAGS = (ALL => [@EXPORT, @EXPORT_OK]);
   8  
   9  use strict;
  10  
  11  sub croak {
  12      require Carp;
  13      goto &Carp::croak;
  14  }
  15  
  16  sub carp {
  17      require Carp;
  18      goto &Carp::carp;
  19  }
  20  
  21  ## forward declaration(s) rather than wrapping the bootstrap call in BEGIN{}
  22  #sub reftype ($) ;
  23  #sub _fetch_attrs ($) ;
  24  #sub _guess_stash ($) ;
  25  #sub _modify_attrs ;
  26  #sub _warn_reserved () ;
  27  #
  28  # The extra trips through newATTRSUB in the interpreter wipe out any savings
  29  # from avoiding the BEGIN block.  Just do the bootstrap now.
  30  BEGIN { bootstrap }
  31  
  32  sub import {
  33      @_ > 2 && ref $_[2] or do {
  34      require Exporter;
  35      goto &Exporter::import;
  36      };
  37      my (undef,$home_stash,$svref,@attrs) = @_;
  38  
  39      my $svtype = uc reftype($svref);
  40      my $pkgmeth;
  41      $pkgmeth = UNIVERSAL::can($home_stash, "MODIFY_$svtype}_ATTRIBUTES")
  42      if defined $home_stash && $home_stash ne '';
  43      my @badattrs;
  44      if ($pkgmeth) {
  45      my @pkgattrs = _modify_attrs($svref, @attrs);
  46      @badattrs = $pkgmeth->($home_stash, $svref, @attrs);
  47      if (!@badattrs && @pkgattrs) {
  48          return unless _warn_reserved;
  49          @pkgattrs = grep { m/\A[[:lower:]]+(?:\z|\()/ } @pkgattrs;
  50          if (@pkgattrs) {
  51          for my $attr (@pkgattrs) {
  52              $attr =~ s/\(.+\z//s;
  53          }
  54          my $s = ((@pkgattrs == 1) ? '' : 's');
  55          carp "$svtype package attribute$s " .
  56              "may clash with future reserved word$s: " .
  57              join(' : ' , @pkgattrs);
  58          }
  59      }
  60      }
  61      else {
  62      @badattrs = _modify_attrs($svref, @attrs);
  63      }
  64      if (@badattrs) {
  65      croak "Invalid $svtype attribute" .
  66          (( @badattrs == 1 ) ? '' : 's') .
  67          ": " .
  68          join(' : ', @badattrs);
  69      }
  70  }
  71  
  72  sub get ($) {
  73      @_ == 1  && ref $_[0] or
  74      croak 'Usage: '.__PACKAGE__.'::get $ref';
  75      my $svref = shift;
  76      my $svtype = uc reftype $svref;
  77      my $stash = _guess_stash $svref;
  78      $stash = caller unless defined $stash;
  79      my $pkgmeth;
  80      $pkgmeth = UNIVERSAL::can($stash, "FETCH_$svtype}_ATTRIBUTES")
  81      if defined $stash && $stash ne '';
  82      return $pkgmeth ?
  83          (_fetch_attrs($svref), $pkgmeth->($stash, $svref)) :
  84          (_fetch_attrs($svref))
  85      ;
  86  }
  87  
  88  sub require_version { goto &UNIVERSAL::VERSION }
  89  
  90  1;
  91  __END__
  92  #The POD goes here
  93  
  94  =head1 NAME
  95  
  96  attributes - get/set subroutine or variable attributes
  97  
  98  =head1 SYNOPSIS
  99  
 100    sub foo : method ;
 101    my ($x,@y,%z) : Bent ;
 102    my $s = sub : method { ... };
 103  
 104    use attributes ();    # optional, to get subroutine declarations
 105    my @attrlist = attributes::get(\&foo);
 106  
 107    use attributes 'get'; # import the attributes::get subroutine
 108    my @attrlist = get \&foo;
 109  
 110  =head1 DESCRIPTION
 111  
 112  Subroutine declarations and definitions may optionally have attribute lists
 113  associated with them.  (Variable C<my> declarations also may, but see the
 114  warning below.)  Perl handles these declarations by passing some information
 115  about the call site and the thing being declared along with the attribute
 116  list to this module.  In particular, the first example above is equivalent to
 117  the following:
 118  
 119      use attributes __PACKAGE__, \&foo, 'method';
 120  
 121  The second example in the synopsis does something equivalent to this:
 122  
 123      use attributes __PACKAGE__, \$x, 'Bent';
 124      use attributes __PACKAGE__, \@y, 'Bent';
 125      use attributes __PACKAGE__, \%z, 'Bent';
 126  
 127  Yes, that's three invocations.
 128  
 129  B<WARNING>: attribute declarations for variables are an I<experimental>
 130  feature.  The semantics of such declarations could change or be removed
 131  in future versions.  They are present for purposes of experimentation
 132  with what the semantics ought to be.  Do not rely on the current
 133  implementation of this feature.
 134  
 135  There are only a few attributes currently handled by Perl itself (or
 136  directly by this module, depending on how you look at it.)  However,
 137  package-specific attributes are allowed by an extension mechanism.
 138  (See L<"Package-specific Attribute Handling"> below.)
 139  
 140  The setting of attributes happens at compile time.  An attempt to set
 141  an unrecognized attribute is a fatal error.  (The error is trappable, but
 142  it still stops the compilation within that C<eval>.)  Setting an attribute
 143  with a name that's all lowercase letters that's not a built-in attribute
 144  (such as "foo")
 145  will result in a warning with B<-w> or C<use warnings 'reserved'>.
 146  
 147  =head2 Built-in Attributes
 148  
 149  The following are the built-in attributes for subroutines:
 150  
 151  =over 4
 152  
 153  =item locked
 154  
 155  Setting this attribute is only meaningful when the subroutine or
 156  method is to be called by multiple threads.  When set on a method
 157  subroutine (i.e., one marked with the B<method> attribute below),
 158  Perl ensures that any invocation of it implicitly locks its first
 159  argument before execution.  When set on a non-method subroutine,
 160  Perl ensures that a lock is taken on the subroutine itself before
 161  execution.  The semantics of the lock are exactly those of one
 162  explicitly taken with the C<lock> operator immediately after the
 163  subroutine is entered.
 164  
 165  =item method
 166  
 167  Indicates that the referenced subroutine is a method.
 168  This has a meaning when taken together with the B<locked> attribute,
 169  as described there.  It also means that a subroutine so marked
 170  will not trigger the "Ambiguous call resolved as CORE::%s" warning.
 171  
 172  =item lvalue
 173  
 174  Indicates that the referenced subroutine is a valid lvalue and can
 175  be assigned to. The subroutine must return a modifiable value such
 176  as a scalar variable, as described in L<perlsub>.
 177  
 178  =back
 179  
 180  There are no built-in attributes for anything other than subroutines.
 181  
 182  =head2 Available Subroutines
 183  
 184  The following subroutines are available for general use once this module
 185  has been loaded:
 186  
 187  =over 4
 188  
 189  =item get
 190  
 191  This routine expects a single parameter--a reference to a
 192  subroutine or variable.  It returns a list of attributes, which may be
 193  empty.  If passed invalid arguments, it uses die() (via L<Carp::croak|Carp>)
 194  to raise a fatal exception.  If it can find an appropriate package name
 195  for a class method lookup, it will include the results from a
 196  C<FETCH_I<type>_ATTRIBUTES> call in its return list, as described in
 197  L<"Package-specific Attribute Handling"> below.
 198  Otherwise, only L<built-in attributes|"Built-in Attributes"> will be returned.
 199  
 200  =item reftype
 201  
 202  This routine expects a single parameter--a reference to a subroutine or
 203  variable.  It returns the built-in type of the referenced variable,
 204  ignoring any package into which it might have been blessed.
 205  This can be useful for determining the I<type> value which forms part of
 206  the method names described in L<"Package-specific Attribute Handling"> below.
 207  
 208  =back
 209  
 210  Note that these routines are I<not> exported by default.
 211  
 212  =head2 Package-specific Attribute Handling
 213  
 214  B<WARNING>: the mechanisms described here are still experimental.  Do not
 215  rely on the current implementation.  In particular, there is no provision
 216  for applying package attributes to 'cloned' copies of subroutines used as
 217  closures.  (See L<perlref/"Making References"> for information on closures.)
 218  Package-specific attribute handling may change incompatibly in a future
 219  release.
 220  
 221  When an attribute list is present in a declaration, a check is made to see
 222  whether an attribute 'modify' handler is present in the appropriate package
 223  (or its @ISA inheritance tree).  Similarly, when C<attributes::get> is
 224  called on a valid reference, a check is made for an appropriate attribute
 225  'fetch' handler.  See L<"EXAMPLES"> to see how the "appropriate package"
 226  determination works.
 227  
 228  The handler names are based on the underlying type of the variable being
 229  declared or of the reference passed.  Because these attributes are
 230  associated with subroutine or variable declarations, this deliberately
 231  ignores any possibility of being blessed into some package.  Thus, a
 232  subroutine declaration uses "CODE" as its I<type>, and even a blessed
 233  hash reference uses "HASH" as its I<type>.
 234  
 235  The class methods invoked for modifying and fetching are these:
 236  
 237  =over 4
 238  
 239  =item FETCH_I<type>_ATTRIBUTES
 240  
 241  This method receives a single argument, which is a reference to the
 242  variable or subroutine for which package-defined attributes are desired.
 243  The expected return value is a list of associated attributes.
 244  This list may be empty.
 245  
 246  =item MODIFY_I<type>_ATTRIBUTES
 247  
 248  This method is called with two fixed arguments, followed by the list of
 249  attributes from the relevant declaration.  The two fixed arguments are
 250  the relevant package name and a reference to the declared subroutine or
 251  variable.  The expected return value as a list of attributes which were
 252  not recognized by this handler.  Note that this allows for a derived class
 253  to delegate a call to its base class, and then only examine the attributes
 254  which the base class didn't already handle for it.
 255  
 256  The call to this method is currently made I<during> the processing of the
 257  declaration.  In particular, this means that a subroutine reference will
 258  probably be for an undefined subroutine, even if this declaration is
 259  actually part of the definition.
 260  
 261  =back
 262  
 263  Calling C<attributes::get()> from within the scope of a null package
 264  declaration C<package ;> for an unblessed variable reference will
 265  not provide any starting package name for the 'fetch' method lookup.
 266  Thus, this circumstance will not result in a method call for package-defined
 267  attributes.  A named subroutine knows to which symbol table entry it belongs
 268  (or originally belonged), and it will use the corresponding package.
 269  An anonymous subroutine knows the package name into which it was compiled
 270  (unless it was also compiled with a null package declaration), and so it
 271  will use that package name.
 272  
 273  =head2 Syntax of Attribute Lists
 274  
 275  An attribute list is a sequence of attribute specifications, separated by
 276  whitespace or a colon (with optional whitespace).
 277  Each attribute specification is a simple
 278  name, optionally followed by a parenthesised parameter list.
 279  If such a parameter list is present, it is scanned past as for the rules
 280  for the C<q()> operator.  (See L<perlop/"Quote and Quote-like Operators">.)
 281  The parameter list is passed as it was found, however, and not as per C<q()>.
 282  
 283  Some examples of syntactically valid attribute lists:
 284  
 285      switch(10,foo(7,3))  :  expensive
 286      Ugly('\(") :Bad
 287      _5x5
 288      locked method
 289  
 290  Some examples of syntactically invalid attribute lists (with annotation):
 291  
 292      switch(10,foo()        # ()-string not balanced
 293      Ugly('(')            # ()-string not balanced
 294      5x5                # "5x5" not a valid identifier
 295      Y2::north            # "Y2::north" not a simple identifier
 296      foo + bar            # "+" neither a colon nor whitespace
 297  
 298  =head1 EXPORTS
 299  
 300  =head2 Default exports
 301  
 302  None.
 303  
 304  =head2 Available exports
 305  
 306  The routines C<get> and C<reftype> are exportable.
 307  
 308  =head2 Export tags defined
 309  
 310  The C<:ALL> tag will get all of the above exports.
 311  
 312  =head1 EXAMPLES
 313  
 314  Here are some samples of syntactically valid declarations, with annotation
 315  as to how they resolve internally into C<use attributes> invocations by
 316  perl.  These examples are primarily useful to see how the "appropriate
 317  package" is found for the possible method lookups for package-defined
 318  attributes.
 319  
 320  =over 4
 321  
 322  =item 1.
 323  
 324  Code:
 325  
 326      package Canine;
 327      package Dog;
 328      my Canine $spot : Watchful ;
 329  
 330  Effect:
 331  
 332      use attributes Canine => \$spot, "Watchful";
 333  
 334  =item 2.
 335  
 336  Code:
 337  
 338      package Felis;
 339      my $cat : Nervous;
 340  
 341  Effect:
 342  
 343      use attributes Felis => \$cat, "Nervous";
 344  
 345  =item 3.
 346  
 347  Code:
 348  
 349      package X;
 350      sub foo : locked ;
 351  
 352  Effect:
 353  
 354      use attributes X => \&foo, "locked";
 355  
 356  =item 4.
 357  
 358  Code:
 359  
 360      package X;
 361      sub Y::x : locked { 1 }
 362  
 363  Effect:
 364  
 365      use attributes Y => \&Y::x, "locked";
 366  
 367  =item 5.
 368  
 369  Code:
 370  
 371      package X;
 372      sub foo { 1 }
 373  
 374      package Y;
 375      BEGIN { *bar = \&X::foo; }
 376  
 377      package Z;
 378      sub Y::bar : locked ;
 379  
 380  Effect:
 381  
 382      use attributes X => \&X::foo, "locked";
 383  
 384  =back
 385  
 386  This last example is purely for purposes of completeness.  You should not
 387  be trying to mess with the attributes of something in a package that's
 388  not your own.
 389  
 390  =head1 SEE ALSO
 391  
 392  L<perlsub/"Private Variables via my()"> and
 393  L<perlsub/"Subroutine Attributes"> for details on the basic declarations;
 394  L<attrs> for the obsolescent form of subroutine attribute specification
 395  which this module replaces;
 396  L<perlfunc/use> for details on the normal invocation mechanism.
 397  
 398  =cut
 399