home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / perl560.zip / lib / attributes.pm < prev    next >
Text File  |  2000-02-19  |  12KB  |  400 lines

  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.  
  400.