1 package Attribute::Handlers;
6 use vars qw($VERSION $AUTOLOAD);
12 my ($pkg, $ref, $type) = @_;
13 return $symcache{$pkg,$ref} if $symcache{$pkg,$ref};
17 foreach my $sym ( values %{$pkg."::"} ) {
19 next unless ref ( \$sym ) eq 'GLOB';
20 return $symcache{$pkg,$ref} = \$sym
21 if *{$sym}{$type} && *{$sym}{$type} == $ref;
26 VAR => [qw[SCALAR ARRAY HASH]],
27 ANY => [qw[SCALAR ARRAY HASH CODE]],
28 "" => [qw[SCALAR ARRAY HASH CODE]],
29 SCALAR => [qw[SCALAR]],
38 my %sigil = (SCALAR=>'$', ARRAY=>'@', HASH=>'%');
46 my @global_phases = qw(BEGIN CHECK INIT END);
49 croak "Usage: use $_[0] autotie => {AttrName => TieClassName,...}";
52 my $qual_id = qr/^[_a-z]\w*(::[_a-z]\w*)*$/i;
56 return unless $class eq "Attribute::Handlers";
59 if ($cmd =~ /^autotie((?:ref)?)$/) {
60 my $tiedata = ($1 ? '$ref, ' : '') . '@$data';
62 _usage_AH_ $class unless ref($mapping) eq 'HASH';
63 while (my($attr, $tieclass) = each %$mapping) {
64 $tieclass =~ s/^([_a-z]\w*(::[_a-z]\w*)*)(.*)/$1/is;
66 _usage_AH_ $class unless $attr =~ $qual_id
67 && $tieclass =~ $qual_id
68 && eval "use base q\0$tieclass\0; 1";
69 if ($tieclass->isa('Exporter')) {
70 local $Exporter::ExportLevel = 2;
71 $tieclass->import(eval $args);
73 $attr =~ s/__CALLER__/caller(1)/e;
74 $attr = caller()."::".$attr unless $attr =~ /::/;
76 sub $attr : ATTR(VAR) {
77 my (\$ref, \$data) = \@_[2,4];
78 my \$was_arrayref = ref \$data eq 'ARRAY';
79 \$data = [ \$data ] unless \$was_arrayref;
80 my \$type = ref(\$ref)||"value (".(\$ref||"<undef>").")";
81 (\$type eq 'SCALAR')? tie \$\$ref,'$tieclass',$tiedata
82 :(\$type eq 'ARRAY') ? tie \@\$ref,'$tieclass',$tiedata
83 :(\$type eq 'HASH') ? tie \%\$ref,'$tieclass',$tiedata
84 : die "Can't autotie a \$type\n"
86 } or die "Internal error: $@";
90 croak "Can't understand $_";
94 sub _resolve_lastattr {
95 return unless $lastattr{ref};
96 my $sym = findsym @lastattr{'pkg','ref'}
97 or die "Internal error: $lastattr{pkg} symbol went missing";
98 my $name = *{$sym}{NAME};
99 warn "Declaration of $name attribute in package $lastattr{pkg} may clash with future reserved word\n"
100 if $^W and $name !~ /[A-Z]/;
101 foreach ( @{$validtype{$lastattr{type}}} ) {
103 *{"$lastattr{pkg}::_ATTR_${_}_${name}"} = $lastattr{ref};
109 return if $AUTOLOAD =~ /::DESTROY$/;
110 my ($class) = $AUTOLOAD =~ m/(.*)::/g;
111 $AUTOLOAD =~ m/_ATTR_(.*?)_(.*)/ or
112 croak "Can't locate class method '$AUTOLOAD' via package '$class'";
113 croak "Attribute handler '$2' doesn't handle $1 attributes";
116 my $builtin = qr/lvalue|method|locked|unique|shared/;
118 sub _gen_handler_AH_() {
121 my ($pkg, $ref, @attrs) = @_;
122 my (undef, $filename, $linenum) = caller 2;
124 my ($attr, $data) = /^([a-z_]\w*)(?:[(](.*)[)])?$/is or next;
125 if ($attr eq 'ATTR') {
128 $raw{$ref} = $data =~ s/\s*,?\s*RAWDATA\s*,?\s*//;
129 $phase{$ref}{BEGIN} = 1
130 if $data =~ s/\s*,?\s*(BEGIN)\s*,?\s*//;
131 $phase{$ref}{INIT} = 1
132 if $data =~ s/\s*,?\s*(INIT)\s*,?\s*//;
133 $phase{$ref}{END} = 1
134 if $data =~ s/\s*,?\s*(END)\s*,?\s*//;
135 $phase{$ref}{CHECK} = 1
136 if $data =~ s/\s*,?\s*(CHECK)\s*,?\s*//
137 || ! keys %{$phase{$ref}};
138 # Added for cleanup to not pollute next call.
140 croak "Can't have two ATTR specifiers on one subroutine"
142 croak "Bad attribute type: ATTR($data)"
143 unless $validtype{$data};
144 %lastattr=(pkg=>$pkg,ref=>$ref,type=>$data);
148 my $handler = $pkg->can("_ATTR_${type}_${attr}");
149 next unless $handler;
150 my $decl = [$pkg, $ref, $attr, $data,
151 $raw{$handler}, $phase{$handler}, $filename, $linenum];
152 foreach my $gphase (@global_phases) {
153 _apply_handler_AH_($decl,$gphase)
154 if $global_phases{$gphase} <= $global_phase;
156 if ($global_phase != 0) {
157 # if _gen_handler_AH_ is being called after
158 # CHECK it's for a lexical, so make sure
159 # it didn't want to run anything later
161 local $Carp::CarpLevel = 2;
162 carp "Won't be able to apply END handler"
163 if $phase{$handler}{END};
166 push @declarations, $decl
171 return grep {defined && !/$builtin/} @attrs;
177 *{"Attribute::Handlers::UNIVERSAL::MODIFY_${_}_ATTRIBUTES"} =
178 _gen_handler_AH_ foreach @{$validtype{ANY}};
180 push @UNIVERSAL::ISA, 'Attribute::Handlers::UNIVERSAL'
181 unless grep /^Attribute::Handlers::UNIVERSAL$/, @UNIVERSAL::ISA;
183 sub _apply_handler_AH_ {
184 my ($declaration, $phase) = @_;
185 my ($pkg, $ref, $attr, $data, $raw, $handlerphase, $filename, $linenum) = @$declaration;
186 return unless $handlerphase->{$phase};
187 # print STDERR "Handling $attr on $ref in $phase with [$data]\n";
189 my $handler = "_ATTR_${type}_${attr}";
190 my $sym = findsym($pkg, $ref);
191 $sym ||= $type eq 'CODE' ? 'ANON' : 'LEXICAL';
193 if (!$raw && defined($data)) {
195 my $evaled = eval("package $pkg; no warnings; no strict;
196 local \$SIG{__WARN__}=sub{die}; [$data]");
197 $data = $evaled unless $@;
199 else { $data = undef }
202 (ref $sym eq 'GLOB' ? *{$sym}{ref $ref}||$ref : $ref),
217 _apply_handler_AH_($_,'CHECK') foreach @declarations;
222 _apply_handler_AH_($_,'INIT') foreach @declarations
226 END { $global_phase++; _apply_handler_AH_($_,'END') foreach @declarations }
233 Attribute::Handlers - Simpler definition of attribute handlers
237 This document describes version 0.79 of Attribute::Handlers,
238 released November 25, 2007.
244 use Attribute::Handlers;
245 no warnings 'redefine';
248 sub Good : ATTR(SCALAR) {
249 my ($package, $symbol, $referent, $attr, $data) = @_;
251 # Invoked for any scalar variable with a :Good attribute,
252 # provided the variable was declared in MyClass (or
253 # a derived class) or typed to MyClass.
255 # Do whatever to $referent here (executed in CHECK phase).
259 sub Bad : ATTR(SCALAR) {
260 # Invoked for any scalar variable with a :Bad attribute,
261 # provided the variable was declared in MyClass (or
262 # a derived class) or typed to MyClass.
266 sub Good : ATTR(ARRAY) {
267 # Invoked for any array variable with a :Good attribute,
268 # provided the variable was declared in MyClass (or
269 # a derived class) or typed to MyClass.
273 sub Good : ATTR(HASH) {
274 # Invoked for any hash variable with a :Good attribute,
275 # provided the variable was declared in MyClass (or
276 # a derived class) or typed to MyClass.
280 sub Ugly : ATTR(CODE) {
281 # Invoked for any subroutine declared in MyClass (or a
282 # derived class) with an :Ugly attribute.
287 # Invoked for any scalar, array, hash, or subroutine
288 # with an :Omni attribute, provided the variable or
289 # subroutine was declared in MyClass (or a derived class)
290 # or the variable was typed to MyClass.
291 # Use ref($_[2]) to determine what kind of referent it was.
296 use Attribute::Handlers autotie => { Cycle => Tie::Cycle };
298 my $next : Cycle(['A'..'Z']);
303 This module, when inherited by a package, allows that package's class to
304 define attribute handler subroutines for specific attributes. Variables
305 and subroutines subsequently defined in that package, or in packages
306 derived from that package may be given attributes with the same names as
307 the attribute handler subroutines, which will then be called in one of
308 the compilation phases (i.e. in a C<BEGIN>, C<CHECK>, C<INIT>, or C<END>
309 block). (C<UNITCHECK> blocks don't correspond to a global compilation
310 phase, so they can't be specified here.)
312 To create a handler, define it as a subroutine with the same name as
313 the desired attribute, and declare the subroutine itself with the
314 attribute C<:ATTR>. For example:
317 use Attribute::Handlers;
320 my ($package, $symbol, $referent, $attr, $data, $phase, $filename, $linenum) = @_;
323 *{$symbol}{NAME}, " ",
324 "($referent) ", "was just declared ",
325 "and ascribed the ${attr} attribute ",
326 "with data ($data)\n",
328 "in file $filename at line $linenum\n";
331 This creates a handler for the attribute C<:Loud> in the class LoudDecl.
332 Thereafter, any subroutine declared with a C<:Loud> attribute in the class
339 causes the above handler to be invoked, and passed:
345 the name of the package into which it was declared;
349 a reference to the symbol table entry (typeglob) containing the subroutine;
353 a reference to the subroutine;
357 the name of the attribute;
361 any data associated with that attribute;
365 the name of the phase in which the handler is being invoked;
369 the filename in which the handler is being invoked;
373 the line number in this file.
377 Likewise, declaring any variables with the C<:Loud> attribute within the
386 will cause the handler to be called with a similar argument list (except,
387 of course, that C<$_[2]> will be a reference to the variable).
389 The package name argument will typically be the name of the class into
390 which the subroutine was declared, but it may also be the name of a derived
391 class (since handlers are inherited).
393 If a lexical variable is given an attribute, there is no symbol table to
394 which it belongs, so the symbol table argument (C<$_[1]>) is set to the
395 string C<'LEXICAL'> in that case. Likewise, ascribing an attribute to
396 an anonymous subroutine results in a symbol table argument of C<'ANON'>.
398 The data argument passes in the value (if any) associated with the
399 attribute. For example, if C<&foo> had been declared:
401 sub foo :Loud("turn it up to 11, man!") {...}
403 then a reference to an array containing the string
404 C<"turn it up to 11, man!"> would be passed as the last argument.
406 Attribute::Handlers makes strenuous efforts to convert
407 the data argument (C<$_[4]>) to a useable form before passing it to
408 the handler (but see L<"Non-interpretive attribute handlers">).
409 If those efforts succeed, the interpreted data is passed in an array
410 reference; if they fail, the raw data is passed as a string.
411 For example, all of these:
413 sub foo :Loud(till=>ears=>are=>bleeding) {...}
414 sub foo :Loud(qw/till ears are bleeding/) {...}
415 sub foo :Loud(qw/my, ears, are, bleeding/) {...}
416 sub foo :Loud(till,ears,are,bleeding) {...}
418 causes it to pass C<['till','ears','are','bleeding']> as the handler's
419 data argument. While:
421 sub foo :Loud(['till','ears','are','bleeding']) {...}
423 causes it to pass C<[ ['till','ears','are','bleeding'] ]>; the array
424 reference specified in the data being passed inside the standard
425 array reference indicating successful interpretation.
427 However, if the data can't be parsed as valid Perl, then
428 it is passed as an uninterpreted string. For example:
430 sub foo :Loud(my,ears,are,bleeding) {...}
431 sub foo :Loud(qw/my ears are bleeding) {...}
433 cause the strings C<'my,ears,are,bleeding'> and
434 C<'qw/my ears are bleeding'> respectively to be passed as the
437 If no value is associated with the attribute, C<undef> is passed.
439 =head2 Typed lexicals
441 Regardless of the package in which it is declared, if a lexical variable is
442 ascribed an attribute, the handler that is invoked is the one belonging to
443 the package to which it is typed. For example, the following declarations:
447 my LoudDecl $loudobj : Loud;
448 my LoudDecl @loudobjs : Loud;
449 my LoudDecl %loudobjex : Loud;
451 causes the LoudDecl::Loud handler to be invoked (even if OtherClass also
452 defines a handler for C<:Loud> attributes).
455 =head2 Type-specific attribute handlers
457 If an attribute handler is declared and the C<:ATTR> specifier is
458 given the name of a built-in type (C<SCALAR>, C<ARRAY>, C<HASH>, or C<CODE>),
459 the handler is only applied to declarations of that type. For example,
460 the following definition:
464 sub RealLoud :ATTR(SCALAR) { print "Yeeeeow!" }
466 creates an attribute handler that applies only to scalars:
472 my $metal : RealLoud; # invokes &LoudDecl::RealLoud
473 my @metal : RealLoud; # error: unknown attribute
474 my %metal : RealLoud; # error: unknown attribute
475 sub metal : RealLoud {...} # error: unknown attribute
477 You can, of course, declare separate handlers for these types as well
478 (but you'll need to specify C<no warnings 'redefine'> to do it quietly):
481 use Attribute::Handlers;
482 no warnings 'redefine';
484 sub RealLoud :ATTR(SCALAR) { print "Yeeeeow!" }
485 sub RealLoud :ATTR(ARRAY) { print "Urrrrrrrrrr!" }
486 sub RealLoud :ATTR(HASH) { print "Arrrrrgggghhhhhh!" }
487 sub RealLoud :ATTR(CODE) { croak "Real loud sub torpedoed" }
489 You can also explicitly indicate that a single handler is meant to be
490 used for all types of referents like so:
493 use Attribute::Handlers;
495 sub SeriousLoud :ATTR(ANY) { warn "Hearing loss imminent" }
497 (I.e. C<ATTR(ANY)> is a synonym for C<:ATTR>).
500 =head2 Non-interpretive attribute handlers
502 Occasionally the strenuous efforts Attribute::Handlers makes to convert
503 the data argument (C<$_[4]>) to a useable form before passing it to
504 the handler get in the way.
506 You can turn off that eagerness-to-help by declaring
507 an attribute handler with the keyword C<RAWDATA>. For example:
509 sub Raw : ATTR(RAWDATA) {...}
510 sub Nekkid : ATTR(SCALAR,RAWDATA) {...}
511 sub Au::Naturale : ATTR(RAWDATA,ANY) {...}
513 Then the handler makes absolutely no attempt to interpret the data it
514 receives and simply passes it as a string:
516 my $power : Raw(1..100); # handlers receives "1..100"
518 =head2 Phase-specific attribute handlers
520 By default, attribute handlers are called at the end of the compilation
521 phase (in a C<CHECK> block). This seems to be optimal in most cases because
522 most things that can be defined are defined by that point but nothing has
525 However, it is possible to set up attribute handlers that are called at
526 other points in the program's compilation or execution, by explicitly
527 stating the phase (or phases) in which you wish the attribute handler to
528 be called. For example:
530 sub Early :ATTR(SCALAR,BEGIN) {...}
531 sub Normal :ATTR(SCALAR,CHECK) {...}
532 sub Late :ATTR(SCALAR,INIT) {...}
533 sub Final :ATTR(SCALAR,END) {...}
534 sub Bookends :ATTR(SCALAR,BEGIN,END) {...}
536 As the last example indicates, a handler may be set up to be (re)called in
537 two or more phases. The phase name is passed as the handler's final argument.
539 Note that attribute handlers that are scheduled for the C<BEGIN> phase
540 are handled as soon as the attribute is detected (i.e. before any
541 subsequently defined C<BEGIN> blocks are executed).
544 =head2 Attributes as C<tie> interfaces
546 Attributes make an excellent and intuitive interface through which to tie
547 variables. For example:
549 use Attribute::Handlers;
552 sub UNIVERSAL::Cycle : ATTR(SCALAR) {
553 my ($package, $symbol, $referent, $attr, $data, $phase) = @_;
554 $data = [ $data ] unless ref $data eq 'ARRAY';
555 tie $$referent, 'Tie::Cycle', $data;
562 my $next : Cycle('A'..'Z'); # $next is now a tied variable
568 Note that, because the C<Cycle> attribute receives its arguments in the
569 C<$data> variable, if the attribute is given a list of arguments, C<$data>
570 will consist of a single array reference; otherwise, it will consist of the
571 single argument directly. Since Tie::Cycle requires its cycling values to
572 be passed as an array reference, this means that we need to wrap
573 non-array-reference arguments in an array constructor:
575 $data = [ $data ] unless ref $data eq 'ARRAY';
577 Typically, however, things are the other way around: the tieable class expects
578 its arguments as a flattened list, so the attribute looks like:
580 sub UNIVERSAL::Cycle : ATTR(SCALAR) {
581 my ($package, $symbol, $referent, $attr, $data, $phase) = @_;
582 my @data = ref $data eq 'ARRAY' ? @$data : $data;
583 tie $$referent, 'Tie::Whatever', @data;
587 This software pattern is so widely applicable that Attribute::Handlers
588 provides a way to automate it: specifying C<'autotie'> in the
589 C<use Attribute::Handlers> statement. So, the cycling example,
590 could also be written:
592 use Attribute::Handlers autotie => { Cycle => 'Tie::Cycle' };
598 my $next : Cycle(['A'..'Z']); # $next is now a tied variable
603 Note that we now have to pass the cycling values as an array reference,
604 since the C<autotie> mechanism passes C<tie> a list of arguments as a list
605 (as in the Tie::Whatever example), I<not> as an array reference (as in
606 the original Tie::Cycle example at the start of this section).
608 The argument after C<'autotie'> is a reference to a hash in which each key is
609 the name of an attribute to be created, and each value is the class to which
610 variables ascribed that attribute should be tied.
612 Note that there is no longer any need to import the Tie::Cycle module --
613 Attribute::Handlers takes care of that automagically. You can even pass
614 arguments to the module's C<import> subroutine, by appending them to the
615 class name. For example:
617 use Attribute::Handlers
618 autotie => { Dir => 'Tie::Dir qw(DIR_UNLINK)' };
620 If the attribute name is unqualified, the attribute is installed in the
621 current package. Otherwise it is installed in the qualifier's package:
625 use Attribute::Handlers autotie => {
626 Other::Good => Tie::SecureHash, # tie attr installed in Other::
627 Bad => Tie::Taxes, # tie attr installed in Here::
628 UNIVERSAL::Ugly => Software::Patent # tie attr installed everywhere
631 Autoties are most commonly used in the module to which they actually tie,
632 and need to export their attributes to any module that calls them. To
633 facilitate this, Attribute::Handlers recognizes a special "pseudo-class" --
634 C<__CALLER__>, which may be specified as the qualifier of an attribute:
636 package Tie::Me::Kangaroo:Down::Sport;
638 use Attribute::Handlers autotie => { '__CALLER__::Roo' => __PACKAGE__ };
640 This causes Attribute::Handlers to define the C<Roo> attribute in the package
641 that imports the Tie::Me::Kangaroo:Down::Sport module.
643 Note that it is important to quote the __CALLER__::Roo identifier because
644 a bug in perl 5.8 will refuse to parse it and cause an unknown error.
646 =head3 Passing the tied object to C<tie>
648 Occasionally it is important to pass a reference to the object being tied
649 to the TIESCALAR, TIEHASH, etc. that ties it.
651 The C<autotie> mechanism supports this too. The following code:
653 use Attribute::Handlers autotieref => { Selfish => Tie::Selfish };
654 my $var : Selfish(@args);
656 has the same effect as:
658 tie my $var, 'Tie::Selfish', @args;
660 But when C<"autotieref"> is used instead of C<"autotie">:
662 use Attribute::Handlers autotieref => { Selfish => Tie::Selfish };
663 my $var : Selfish(@args);
665 the effect is to pass the C<tie> call an extra reference to the variable
668 tie my $var, 'Tie::Selfish', \$var, @args;
674 If the class shown in L<SYNOPSIS> were placed in the MyClass.pm
675 module, then the following code:
680 my MyClass $slr :Good :Bad(1**1-1) :Omni(-vorous);
682 package SomeOtherClass;
687 sub fn :Ugly(sister) :Omni('po',tent()) {...}
688 my @arr :Good :Omni(s/cie/nt/);
689 my %hsh :Good(q/bye) :Omni(q/bus/);
692 would cause the following handlers to be invoked:
694 # my MyClass $slr :Good :Bad(1**1-1) :Omni(-vorous);
696 MyClass::Good:ATTR(SCALAR)( 'MyClass', # class
697 'LEXICAL', # no typeglob
701 'CHECK', # compiler phase
704 MyClass::Bad:ATTR(SCALAR)( 'MyClass', # class
705 'LEXICAL', # no typeglob
709 'CHECK', # compiler phase
712 MyClass::Omni:ATTR(SCALAR)( 'MyClass', # class
713 'LEXICAL', # no typeglob
716 '-vorous' # eval'd attr data
717 'CHECK', # compiler phase
721 # sub fn :Ugly(sister) :Omni('po',tent()) {...}
723 MyClass::UGLY:ATTR(CODE)( 'SomeOtherClass', # class
724 \*SomeOtherClass::fn, # typeglob
725 \&SomeOtherClass::fn, # referent
727 'sister' # eval'd attr data
728 'CHECK', # compiler phase
731 MyClass::Omni:ATTR(CODE)( 'SomeOtherClass', # class
732 \*SomeOtherClass::fn, # typeglob
733 \&SomeOtherClass::fn, # referent
735 ['po','acle'] # eval'd attr data
736 'CHECK', # compiler phase
740 # my @arr :Good :Omni(s/cie/nt/);
742 MyClass::Good:ATTR(ARRAY)( 'SomeOtherClass', # class
743 'LEXICAL', # no typeglob
747 'CHECK', # compiler phase
750 MyClass::Omni:ATTR(ARRAY)( 'SomeOtherClass', # class
751 'LEXICAL', # no typeglob
754 "" # eval'd attr data
755 'CHECK', # compiler phase
759 # my %hsh :Good(q/bye) :Omni(q/bus/);
761 MyClass::Good:ATTR(HASH)( 'SomeOtherClass', # class
762 'LEXICAL', # no typeglob
765 'q/bye' # raw attr data
766 'CHECK', # compiler phase
769 MyClass::Omni:ATTR(HASH)( 'SomeOtherClass', # class
770 'LEXICAL', # no typeglob
773 'bus' # eval'd attr data
774 'CHECK', # compiler phase
778 Installing handlers into UNIVERSAL, makes them...err..universal.
781 package Descriptions;
782 use Attribute::Handlers;
785 sub name { return $name{$_[2]}||*{$_[1]}{NAME} }
787 sub UNIVERSAL::Name :ATTR {
788 $name{$_[2]} = $_[4];
791 sub UNIVERSAL::Purpose :ATTR {
792 print STDERR "Purpose of ", &name, " is $_[4]\n";
795 sub UNIVERSAL::Unit :ATTR {
796 print STDERR &name, " measured in $_[4]\n";
803 my $capacity : Name(capacity)
804 : Purpose(to store max storage capacity for files)
810 sub foo : Purpose(to foo all data before barring it) { }
819 =item C<Bad attribute type: ATTR(%s)>
821 An attribute handler was specified with an C<:ATTR(I<ref_type>)>, but the
822 type of referent it was defined to handle wasn't one of the five permitted:
823 C<SCALAR>, C<ARRAY>, C<HASH>, C<CODE>, or C<ANY>.
825 =item C<Attribute handler %s doesn't handle %s attributes>
827 A handler for attributes of the specified name I<was> defined, but not
828 for the specified type of declaration. Typically encountered whe trying
829 to apply a C<VAR> attribute handler to a subroutine, or a C<SCALAR>
830 attribute handler to some other type of variable.
832 =item C<Declaration of %s attribute in package %s may clash with future reserved word>
834 A handler for an attributes with an all-lowercase name was declared. An
835 attribute with an all-lowercase name might have a meaning to Perl
836 itself some day, even though most don't yet. Use a mixed-case attribute
839 =item C<Can't have two ATTR specifiers on one subroutine>
841 You just can't, okay?
842 Instead, put all the specifications together with commas between them
843 in a single C<ATTR(I<specification>)>.
845 =item C<Can't autotie a %s>
847 You can only declare autoties for types C<"SCALAR">, C<"ARRAY">, and
848 C<"HASH">. They're the only things (apart from typeglobs -- which are
849 not declarable) that Perl can tie.
851 =item C<Internal error: %s symbol went missing>
853 Something is rotten in the state of the program. An attributed
854 subroutine ceased to exist between the point it was declared and the point
855 at which its attribute handler(s) would have been called.
857 =item C<Won't be able to apply END handler>
859 You have defined an END handler for an attribute that is being applied
860 to a lexical variable. Since the variable may not be available during END
867 Damian Conway (damian@conway.org)
871 There are undoubtedly serious bugs lurking somewhere in code this funky :-)
872 Bug reports and other feedback are most welcome.
876 Copyright (c) 2001, Damian Conway. All Rights Reserved.
877 This module is free software. It may be used, redistributed
878 and/or modified under the same terms as Perl itself.