package constant;
-
+use 5.005;
use strict;
-use 5.005_64;
use warnings::register;
-our($VERSION, %declared);
-$VERSION = '1.02';
+use vars qw($VERSION %declared);
+$VERSION = '1.17';
#=======================================================================
# Some names are evil choices.
my %keywords = map +($_, 1), qw{ BEGIN INIT CHECK END DESTROY AUTOLOAD };
+$keywords{UNITCHECK}++ if $] > 5.009;
my %forced_into_main = map +($_, 1),
qw{ STDIN STDOUT STDERR ARGV ARGVOUT ENV INC SIG };
sub import {
my $class = shift;
return unless @_; # Ignore 'use constant;'
- my %constants = ();
+ my $constants;
my $multiple = ref $_[0];
+ my $pkg = caller;
+ my $symtab;
+ my $str_end = $] >= 5.006 ? "\\z" : "\\Z";
+
+ if ($] > 5.009002) {
+ no strict 'refs';
+ $symtab = \%{$pkg . '::'};
+ };
if ( $multiple ) {
if (ref $_[0] ne 'HASH') {
require Carp;
Carp::croak("Invalid reference type '".ref(shift)."' not 'HASH'");
}
- %constants = %{+shift};
+ $constants = shift;
} else {
- $constants{+shift} = undef;
+ $constants->{+shift} = undef;
}
- foreach my $name ( keys %constants ) {
+ foreach my $name ( keys %$constants ) {
unless (defined $name) {
require Carp;
Carp::croak("Can't use undef as constant name");
}
- my $pkg = caller;
# Normal constant name
- if ($name =~ /^_?[^\W_0-9]\w*\z/ and !$forbidden{$name}) {
+ if ($name =~ /^_?[^\W_0-9]\w*$str_end/ and !$forbidden{$name}) {
# Everything is okay
# Name forced into main, but we're not in main. Fatal.
Carp::croak("Constant name '$name' begins with '__'");
# Maybe the name is tolerable
- } elsif ($name =~ /^[A-Za-z_]\w*\z/) {
+ } elsif ($name =~ /^[A-Za-z_]\w*$str_end/) {
# Then we'll warn only if you've asked for warnings
if (warnings::enabled()) {
if ($keywords{$name}) {
} elsif ($forced_into_main{$name}) {
warnings::warn("Constant name '$name' is " .
"forced into package main::");
- } else {
- # Catch-all - what did I miss? If you get this error,
- # please let me know what your constant's name was.
- # Write to <rootbeer@redcat.com>. Thanks!
- warnings::warn("Constant name '$name' has unknown problems");
}
}
# Looks like a boolean
# use constant FRED == fred;
- } elsif ($name =~ /^[01]?\z/) {
+ } elsif ($name =~ /^[01]?$str_end/) {
require Carp;
if (@_) {
Carp::croak("Constant name '$name' is invalid");
no strict 'refs';
my $full_name = "${pkg}::$name";
$declared{$full_name}++;
- if ($multiple) {
- my $scalar = $constants{$name};
- *$full_name = sub () { $scalar };
- } else {
- if (@_ == 1) {
- my $scalar = $_[0];
- *$full_name = sub () { $scalar };
- } elsif (@_) {
- my @list = @_;
- *$full_name = sub () { @list };
+ if ($multiple || @_ == 1) {
+ my $scalar = $multiple ? $constants->{$name} : $_[0];
+ if ($symtab && !exists $symtab->{$name}) {
+ # No typeglob yet, so we can use a reference as space-
+ # efficient proxy for a constant subroutine
+ # The check in Perl_ck_rvconst knows that inlinable
+ # constants from cv_const_sv are read only. So we have to:
+ Internals::SvREADONLY($scalar, 1);
+ $symtab->{$name} = \$scalar;
+ mro::method_changed_in($pkg);
} else {
- *$full_name = sub () { };
+ *$full_name = sub () { $scalar };
}
+ } elsif (@_) {
+ my @list = @_;
+ *$full_name = sub () { @list };
+ } else {
+ *$full_name = sub () { };
}
}
}
=head1 SYNOPSIS
- use constant BUFFER_SIZE => 4096;
- use constant ONE_YEAR => 365.2425 * 24 * 60 * 60;
- use constant PI => 4 * atan2 1, 1;
- use constant DEBUGGING => 0;
- use constant ORACLE => 'oracle@cs.indiana.edu';
- use constant USERNAME => scalar getpwuid($<);
- use constant USERINFO => getpwuid($<);
-
- sub deg2rad { PI * $_[0] / 180 }
-
- print "This line does nothing" unless DEBUGGING;
+ use constant PI => 4 * atan2(1, 1);
+ use constant DEBUG => 0;
- # references can be constants
- use constant CHASH => { foo => 42 };
- use constant CARRAY => [ 1,2,3,4 ];
- use constant CPSEUDOHASH => [ { foo => 1}, 42 ];
- use constant CCODE => sub { "bite $_[0]\n" };
+ print "Pi equals ", PI, "...\n" if DEBUG;
- print CHASH->{foo};
- print CARRAY->[$i];
- print CPSEUDOHASH->{foo};
- print CCODE->("me");
- print CHASH->[10]; # compile-time error
-
- # declaring multiple constants at once
use constant {
- BUFFER_SIZE => 4096,
- ONE_YEAR => 365.2425 * 24 * 60 * 60,
- PI => 4 * atan2( 1, 1 ),
- DEBUGGING => 0,
- ORACLE => 'oracle@cs.indiana.edu',
- USERNAME => scalar getpwuid($<),
- USERINFO => getpwuid($<),
+ SEC => 0,
+ MIN => 1,
+ HOUR => 2,
+ MDAY => 3,
+ MON => 4,
+ YEAR => 5,
+ WDAY => 6,
+ YDAY => 7,
+ ISDST => 8,
};
+ use constant WEEKDAYS => qw(
+ Sunday Monday Tuesday Wednesday Thursday Friday Saturday
+ );
+
+ print "Today is ", (WEEKDAYS)[ (localtime)[WDAY] ], ".\n";
+
=head1 DESCRIPTION
-This will declare a symbol to be a constant with the given scalar
-or list value.
+This pragma allows you to declare constants at compile-time.
When you declare a constant such as C<PI> using the method shown
above, each machine your script runs upon can have as many digits
far less likely to send a space probe to the wrong planet because
nobody noticed the one equation in which you wrote C<3.14195>.
+When a constant is used in an expression, Perl replaces it with its
+value at compile time, and may then optimize the expression further.
+In particular, any code in an C<if (CONSTANT)> block will be optimized
+away if the constant is false.
+
=head1 NOTES
-The value or values are evaluated in a list context. You may override
-this with C<scalar> as shown above.
+As with all C<use> directives, defining a constant happens at
+compile time. Thus, it's probably not correct to put a constant
+declaration inside of a conditional statement (like C<if ($foo)
+{ use constant ... }>).
+
+Constants defined using this module cannot be interpolated into
+strings like variables. However, concatenation works just fine:
+
+ print "Pi equals PI...\n"; # WRONG: does not expand "PI"
+ print "Pi equals ".PI."...\n"; # right
-These constants do not directly interpolate into double-quotish
-strings, although you may do so indirectly. (See L<perlref> for
-details about how this works.)
+Even though a reference may be declared as a constant, the reference may
+point to data which may be changed, as this code shows.
- print "The value of PI is @{[ PI ]}.\n";
+ use constant ARRAY => [ 1,2,3,4 ];
+ print ARRAY->[1];
+ ARRAY->[1] = " be changed";
+ print ARRAY->[1];
-List constants are returned as lists, not as arrays.
+Dereferencing constant references incorrectly (such as using an array
+subscript on a constant hash reference, or vice versa) will be trapped at
+compile time.
- $homedir = USERINFO[7]; # WRONG
- $homedir = (USERINFO)[7]; # Right
+Constants belong to the package they are defined in. To refer to a
+constant defined in another package, specify the full package name, as
+in C<Some::Package::CONSTANT>. Constants may be exported by modules,
+and may also be called as either class or instance methods, that is,
+as C<< Some::Package->CONSTANT >> or as C<< $obj->CONSTANT >> where
+C<$obj> is an instance of C<Some::Package>. Subclasses may define
+their own constants to override those in their base class.
The use of all caps for constant names is merely a convention,
although it is recommended in order to make constants stand out
poor choices for names will generate warnings, if warnings are enabled at
compile time.
-Constant symbols are package scoped (rather than block scoped, as
-C<use strict> is). That is, you can refer to a constant from package
-Other as C<Other::CONST>.
+=head2 List constants
-As with all C<use> directives, defining a constant happens at
-compile time. Thus, it's probably not correct to put a constant
-declaration inside of a conditional statement (like C<if ($foo)
-{ use constant ... }>). When defining multiple constants, you
-cannot use the values of other constants within the same declaration
-scope. This is because the calling package doesn't know about any
-constant within that group until I<after> the C<use> statement is
-finished.
+Constants may be lists of more (or less) than one value. A constant
+with no values evaluates to C<undef> in scalar context. Note that
+constants with more than one value do I<not> return their last value in
+scalar context as one might expect. They currently return the number
+of values, but B<this may change in the future>. Do not use constants
+with multiple values in scalar context.
+
+B<NOTE:> This implies that the expression defining the value of a
+constant is evaluated in list context. This may produce surprises:
+
+ use constant TIMESTAMP => localtime; # WRONG!
+ use constant TIMESTAMP => scalar localtime; # right
+
+The first line above defines C<TIMESTAMP> as a 9-element list, as
+returned by C<localtime()> in list context. To set it to the string
+returned by C<localtime()> in scalar context, an explicit C<scalar>
+keyword is required.
+
+List constants are lists, not arrays. To index or slice them, they
+must be placed in parentheses.
+
+ my @workdays = WEEKDAYS[1 .. 5]; # WRONG!
+ my @workdays = (WEEKDAYS)[1 .. 5]; # right
+
+=head2 Defining multiple constants at once
+
+Instead of writing multiple C<use constant> statements, you may define
+multiple constants in a single statement by giving, instead of the
+constant name, a reference to a hash where the keys are the names of
+the constants to be defined. Obviously, all constants defined using
+this method must have a single value.
use constant {
- AGE => 20,
- PERSON => { age => AGE }, # Error!
+ FOO => "A single value",
+ BAR => "This", "won't", "work!", # Error!
};
- [...]
- use constant PERSON => { age => AGE }; # Right
-
-Omitting the value for a symbol gives it the value of C<undef> in
-a scalar context or the empty list, C<()>, in a list context. This
-isn't so nice as it may sound, though, because in this case you
-must either quote the symbol name, or use a big arrow, (C<=E<gt>>),
-with nothing to point to. It is also illegal to do when defining
-multiple constants at once, you must declare them explicitly. It
-is probably best to declare these explicitly.
-
- use constant UNICORNS => ();
- use constant LOGFILE => undef;
-
-The result from evaluating a list constant in a scalar context is
-not documented, and is B<not> guaranteed to be any particular value
-in the future. In particular, you should not rely upon it being
-the number of elements in the list, especially since it is not
-B<necessarily> that value in the current implementation.
-
-Magical values, tied values, and references can be made into
-constants at compile time, allowing for way cool stuff like this.
-(These error numbers aren't totally portable, alas.)
- use constant E2BIG => ($! = 7);
- print E2BIG, "\n"; # something like "Arg list too long"
- print 0+E2BIG, "\n"; # "7"
+This is a fundamental limitation of the way hashes are constructed in
+Perl. The error messages produced when this happens will often be
+quite cryptic -- in the worst case there may be none at all, and
+you'll only later find that something is broken.
-Dereferencing constant references incorrectly (such as using an array
-subscript on a constant hash reference, or vice versa) will be trapped at
-compile time.
+When defining multiple constants, you cannot use the values of other
+constants defined in the same declaration. This is because the
+calling package doesn't know about any constant within that group
+until I<after> the C<use> statement is finished.
-When declaring multiple constants, all constant values will be a scalar.
-This is because C<constant> can't guess the intent of the programmer
-correctly all the time since values must be expressed in scalar context
-within a hash ref.
+ use constant {
+ BITMASK => 0xAFBAEBA8,
+ NEGMASK => ~BITMASK, # Error!
+ };
-In the rare case in which you need to discover at run time whether a
-particular constant has been declared via this module, you may use
-this function to examine the hash C<%constant::declared>. If the given
-constant name does not include a package name, the current package is
-used.
+=head2 Magic constants
- sub declared ($) {
- use constant 1.01; # don't omit this!
- my $name = shift;
- $name =~ s/^::/main::/;
- my $pkg = caller;
- my $full_name = $name =~ /::/ ? $name : "${pkg}::$name";
- $constant::declared{$full_name};
- }
+Magical values and references can be made into constants at compile
+time, allowing for way cool stuff like this. (These error numbers
+aren't totally portable, alas.)
-=head1 TECHNICAL NOTE
+ use constant E2BIG => ($! = 7);
+ print E2BIG, "\n"; # something like "Arg list too long"
+ print 0+E2BIG, "\n"; # "7"
+
+You can't produce a tied constant by giving a tied scalar as the
+value. References to tied variables, however, can be used as
+constants without any problems.
+
+=head1 TECHNICAL NOTES
In the current implementation, scalar constants are actually
inlinable subroutines. As of version 5.004 of Perl, the appropriate
L<perlsub/"Constant Functions"> for details about how and when this
happens.
-=head1 BUGS
+In the rare case in which you need to discover at run time whether a
+particular constant has been declared via this module, you may use
+this function to examine the hash C<%constant::declared>. If the given
+constant name does not include a package name, the current package is
+used.
+
+ sub declared ($) {
+ use constant 1.01; # don't omit this!
+ my $name = shift;
+ $name =~ s/^::/main::/;
+ my $pkg = caller;
+ my $full_name = $name =~ /::/ ? $name : "${pkg}::$name";
+ $constant::declared{$full_name};
+ }
+
+=head1 CAVEATS
In the current version of Perl, list constants are not inlined
and some symbols may be redefined without generating a warning.
-It is not possible to have a subroutine or keyword with the same
+It is not possible to have a subroutine or a keyword with the same
name as a constant in the same package. This is probably a Good Thing.
A constant with a name in the list C<STDIN STDOUT STDERR ARGV ARGVOUT
ENV INC SIG> is not allowed anywhere but in package C<main::>, for
technical reasons.
-Even though a reference may be declared as a constant, the reference may
-point to data which may be changed, as this code shows.
-
- use constant CARRAY => [ 1,2,3,4 ];
- print CARRAY->[1];
- CARRAY->[1] = " be changed";
- print CARRAY->[1];
-
Unlike constants in some languages, these cannot be overridden
on the command line or via environment variables.
For example, you can't say C<$hash{CONSTANT}> because C<CONSTANT> will
be interpreted as a string. Use C<$hash{CONSTANT()}> or
C<$hash{+CONSTANT}> to prevent the bareword quoting mechanism from
-kicking in. Similarly, since the C<=E<gt>> operator quotes a bareword
-immediately to its left, you have to say C<CONSTANT() =E<gt> 'value'>
+kicking in. Similarly, since the C<< => >> operator quotes a bareword
+immediately to its left, you have to say C<< CONSTANT() => 'value' >>
(or simply use a comma in place of the big arrow) instead of
-C<CONSTANT =E<gt> 'value'>.
+C<< CONSTANT => 'value' >>.
+
+=head1 SEE ALSO
+
+L<Readonly> - Facility for creating read-only scalars, arrays, hashes.
-=head1 AUTHOR
+L<Const> - Facility for creating read-only variables. Similar to C<Readonly>,
+but uses C<SvREADONLY> instead of C<tie>.
+
+L<Attribute::Constant> - Make read-only variables via attribute
+
+L<Scalar::Readonly> - Perl extension to the C<SvREADONLY> scalar flag
+
+L<Hash::Util> - A selection of general-utility hash subroutines (mostly
+to lock/unlock keys and values)
+
+=head1 BUGS
+
+Please report any bugs or feature requests via the perlbug(1) utility.
+
+=head1 AUTHORS
Tom Phoenix, E<lt>F<rootbeer@redcat.com>E<gt>, with help from
many other folks.
-Multiple constant declarations at once added by Casey Tweten,
-E<lt>F<crt@kiski.net>E<gt>.
+Multiple constant declarations at once added by Casey West,
+E<lt>F<casey@geeknest.com>E<gt>.
+
+Documentation mostly rewritten by Ilmari Karonen,
+E<lt>F<perl@itz.pp.sci.fi>E<gt>.
+
+This program is maintained by the Perl 5 Porters.
+The CPAN distribution is maintained by SE<eacute>bastien Aperghis-Tramoni
+E<lt>F<sebastien@aperghis.net>E<gt>.
-=head1 COPYRIGHT
+=head1 COPYRIGHT & LICENSE
Copyright (C) 1997, 1999 Tom Phoenix